Calculating vertex normals for an IndexedTriangleStripArray

Question

Hi,
I'm trying to calculate the vertex normals to an IndexedTriangleStripArray, and I can't seem to get it right (Checked against a TriangleStripArray that I generated normals for using NormalGenerator). Basically, i'm generating normals for all of the surfaces that a vertex touches and then taking the average.
I do so by getting a center point (the vertex for which i'm calculating the normal), and all the points surrounding it (see comment above code below), out of a float array of coordinates and creating vectors and then cross producting them. I can't really see what I'm doing wrong. Might be because I've been staring at this for too long. Anyways, any help would be really appreciated.
oh, btw.. i need to use an IndexedTriangleStripArray, so I can't go through GeometryInfo to generate normals.
thanks alot,
nikolai
     * b-c-d
     * a-C-e
     * h-g-f
     *_w -> width of elevation grid
    public void setUpNormals(int[] stripcount)
        _normals = new float[_coords.length];
        float[] vecA = new float[3];
        float[] vecB = new float[3];
        float[] vecC = new float[3];
        float[] vecD = new float[3];
        float[] vecE = new float[3];
        float[] vecF = new float[3];
        float[] vecG = new float[3];
        float[] vecH = new float[3];
        float[] normAB;
        float[] normBC;
        float[] normCD;
        float[] normDE;
        float[] normEF;
        float[] normFG;
        float[] normGH;
        float[] normHA;
        float[] normal = new float[3];
        for(int i = 0; i < _coords.length/3; i++)
            int center = i*3;
            int a = center - 3;
            int b = a - _w*3;
            int c = center - _w*3;
            int d = c + 3;
            int e = center + 3;
            int f = e + _w*3;
            int g = center + _w*3;
            int h = g - 3;
            int row = (center/3)/(_w);
            int col = (center/3)%_w;
            if (col > 0)
                vecA[0] = _coords[a] - _coords[center];
                vecA[1] = _coords[a+1] - _coords[center+1];
                vecA[2] = _coords[a+2] - _coords[center+2];
                if (row>0)
                    vecB[0] = _coords[b] - _coords[center];
                    vecB[1] = _coords[b+1] - _coords[center+1];
                    vecB[2] = _coords[b+2] - _coords[center+2];
                if (row < _w - 1)
                    vecH[0] = _coords[h] - _coords[center];
                    vecH[1] = _coords[h+1] - _coords[center+1];
                    vecH[2] = _coords[h+2] - _coords[center+2];
            else
                vecA = new float[3];
                vecB = new float[3];
                vecH = new float[3];
            if (row>0)
                //vecB already initialized if its to be involved
                vecC[0] = _coords[c] - _coords[center];
                vecC[1] = _coords[c+1] - _coords[center+1];
                vecC[2] = _coords[c+2] - _coords[center+2];
                if (col < _w - 1){
                    vecD[0] = _coords[d] - _coords[center];
                    vecD[1] = _coords[d+1] - _coords[center+1];
                    vecD[2] = _coords[d+2] - _coords[center+2];
            else
                vecB = new float[3];
                vecC = new float[3];
                vecD = new float[3];
            if (col < _w - 1)
                //vecD already initialized
                vecE[0] = _coords[e] - _coords[center];
                vecE[1] = _coords[e+1] - _coords[center+1];
                vecE[2] = _coords[e+2] - _coords[center+2];
                if (row < _w - 1)
                    vecF[0] = _coords[f] - _coords[center];
                    vecF[1] = _coords[f+1] - _coords[center+1];
                    vecF[2] = _coords[f+2] - _coords[center+2];
            else
                vecD = new float[3];
                vecE = new float[3];
                vecF = new float[3];
            if (row < _w - 1)
                //vecF already initialized
                vecG[0] = _coords[g] - _coords[center];
                vecG[1] = _coords[g+1] - _coords[center+1];
                vecG[2] = _coords[g+2] - _coords[center+2];
                //vecH already initialized
            else
                vecF = new float[3];
                vecG = new float[3];
                vecH = new float[3];
            normAB = getNormal(vecA, vecB);
            normBC = getNormal(vecB, vecC);
            normCD = getNormal(vecC, vecD);
            normDE = getNormal(vecD, vecE);
            normEF = getNormal(vecE, vecF);
            normFG = getNormal(vecF, vecG);
            normGH = getNormal(vecG, vecH);
            normHA = getNormal(vecH, vecA);
            normal[0] = normAB[0]+ normBC[0] + normCD[0] + normDE[0] + normEF[0] + normFG[0] + normGH[0] + normHA[0];
            normal[1] = normAB[1]+ normBC[1] + normCD[1] + normDE[1] + normEF[1] + normFG[1] + normGH[1] + normHA[1];
            normal[2] = normAB[2]+ normBC[2] + normCD[2] + normDE[2] + normEF[2] + normFG[2] + normGH[2] + normHA[2];
            float magnitude = (float) Math.sqrt(normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2]);
            normal[0]/=magnitude;
            normal[1]/=magnitude;
            normal[2]/=magnitude;
            _normals[center] = normal[0];
            _normals[center + 1] = normal[1];
            _normals[center + 2] = normal[2];
        return;
    }

Answer 1

Hi Greg,
Its simple :-)
Set the TriangleArray back to COLOR_3 (Specifies this vertex array contains colors without transparency); or it could even be COLOR_4.
Then, attach Appearance / ColoringAttributes / Material / TransparencyAttributes as shown below:
          Appearance a = new Appearance();
          PolygonAttributes pa = new PolygonAttributes( );
          pa.setPolygonMode( PolygonAttributes.POLYGON_FILL );
          pa.setCullFace( PolygonAttributes.CULL_NONE );
          a.setPolygonAttributes( pa );
          ColoringAttributes ca = new ColoringAttributes(0.4f, 1.0f, 0.6f, ColoringAttributes.SHADE_GOURAUD);
          a.setColoringAttributes( ca );
          Material mat = new Material();
          mat.setAmbientColor(0.6f, 0.6f, 0.1f);
          mat.setDiffuseColor(0.6f, 0.3f, 0.0f);
          mat.setEmissiveColor(0.3f, 0.3f, 0.3f);
          mat.setSpecularColor(1.0f, 1.0f, 1.0f);
          mat.setShininess(120.0f);
          a.setMaterial(mat);
          TransparencyAttributes ta = new TransparencyAttributes(1, 0.5f); // this sets the transparency
          ta.setTransparencyMode(ta.BLENDED);
          a.setTransparencyAttributes(ta);I hope this helps :-)
Cool :)
Ravi