example10.java

J2ME手机游戏开发技术详解随书光盘

            System.out.println("Memory available : " + Runtime.getRuntime().freeMemory() + " / " + Runtime.getRuntime().totalMemory());
    }

    //
    private void preInitNokiaScene()
    {
        // Search the node with the 2d bug image and hide it for now..
        World nokia = m_scenes[SCENE_NOKIA];
        Mesh m = (Mesh) nokia.find(UID_NOKIA_ANTIMAGE);
        m.setRenderingEnable(false);

        // Add some snowflakes to the scene
        initSnowFlakes();
    }

    //
    private boolean showBug = false;
    private void updateNokiaScene(int time)
    {
        // Do not show the bug node before certain time has been reached..
        if (time > SCENE_NOKIA_HIDEBUG && !showBug)
        {
            // Search the image node & display it
            World nokia = m_scenes[SCENE_NOKIA];
            Mesh m = (Mesh) nokia.find(UID_NOKIA_ANTIMAGE);
            m.setRenderingEnable(true);

            // Show the lil' fellah :)
            showBug = true;
        }

        // Animate the snowflakes..
        animateSnowFlakes(time);

        // Switch to bug scene when
        // todo: fade out nokia scene properly
        if (time > SCENE_NOKIA_LENGTH || m_nokiaFadeOut)
        {
            //
            freeOldScene();

            // Load the bug scene
            m_scenes[SCENE_BUG] = loadScene("nokia/otokka_jump2");

            //
            m_currentScene = SCENE_BUG;
            m_currentTime = 0;
        }
    }

    //
    private void updateBugScene(int time)
    {
        // Switch to bug scene when
        if (time > SCENE_BUG_LENGTH)
        {
            //
            freeOldScene();

            // Load the pond scene
            m_scenes[SCENE_TUNNEL] = loadScene("nokia/tunnel");
            preInitTunnelScene();

            //
            m_currentScene = SCENE_TUNNEL;
            m_currentTime = 0;
        }
    }

    //
    private void preInitTunnelScene()
    {
        /** Select the world... */
        World w = m_scenes[SCENE_TUNNEL];

        // Find the tunnel mesh
        Mesh tnl = (Mesh) w.find(UID_TUNNEL_MESH);

        // Get the appearance from the mesh
        Appearance ap = tnl.getAppearance(0);

        // Get the vertex buffer for the tunnel mesh
        VertexBuffer vb = tnl.getVertexBuffer();

        // Get vertex count
        int count = vb.getVertexCount();

        // Create a new array for texture coordinates (for texture #2, as the object has only one texture layer defined in swerve)
        tunnelTexCoords = new short[count * 2];

        // Init the array with some random values
        for (int a = 0 ; a < count*2; a++)
        {
            int i = (m_random.nextInt() & 0xFF);
            tunnelTexCoords[a] = (short) i;
        }

        // Create a new vertex array..
        tunnelTextureArray = new VertexArray(count, 2, 2);

        // Copy texture coordinate values to array
        tunnelTextureArray.set(0, count, tunnelTexCoords);

        // Assign texture coordinates to second texture unit.
        vb.setTexCoords(1, tunnelTextureArray, 0.0004f, null);

        // Load texture image ...
        tunnelTextureImage2 = new Image2D(Image2D.RGB, platformServices.loadImage("nokia/ttex2.png"));

        // Create texmap
        tunnelTexture2 = new Texture2D(tunnelTextureImage2);

        // Choose blending mode for the texture layer, additive by default
        tunnelTexture2.setBlending(Texture2D.FUNC_ADD);

        // Backup first texture reference...
        tunnelTexture1 = ap.getTexture(0);

        // Update the textures...
        switchTunnelMode(1);

        // Create linear fog for the tunnel
        tunnelFog = new Fog();
        tunnelFog.setMode(Fog.LINEAR);
        tunnelFog.setColor(0x006080a0);
        tunnelFog.setLinear(10.0f, 25.0f);
    }

    //
    private void updateTunnelScene(int time, int delta)
    {
        // 
        World scn = m_scenes[SCENE_TUNNEL];

        // Find the omni light
        Light l = (Light) scn.find(UID_TUNNEL_LIGHT);

        // Set the light's intensity
        l.setIntensity(m_lightIntensity);

        /** Fade out mode */
        if (m_tunnelFadeOut)
        {
            if (DEBUG)
                System.out.println(delta);

            // Drop intensity
            m_lightIntensity-=(delta * 0.001f);

            // Fade below zero.. Looks like we have ambient light somewhere?
            if (m_lightIntensity <= -2.0f)
            {
                //
                freeOldScene();
    
                //
                m_scenes[SCENE_POND] = loadScene("nokia/pond_vilkutus2");
                preInitPondScene();
    
                //
                m_currentScene = SCENE_POND;
                m_currentTime = 0;
            }
        }
    }

    // Switches between different texture depths
    private void switchTunnelMode(int tnlMode)
    {
        // Select the world...
        World w = m_scenes[SCENE_TUNNEL];

        // Find the tunnel mesh
        Mesh tnl = (Mesh) w.find(UID_TUNNEL_MESH);

        // Get the appearance from the mesh
        Appearance ap = tnl.getAppearance(0);

        // remove textures?
        if (tnlMode == NO_TEXTURE)
        {
            ap.setTexture(0, null);
            ap.setTexture(1, null);
        }
        else
        if (tnlMode == ONE_TEXTURE)
        {
            ap.setTexture(0, tunnelTexture1);
            ap.setTexture(1, null);
        }
        else
        if (tnlMode == DUAL_TEXTURE)
        {
            ap.setTexture(0, tunnelTexture1);
            ap.setTexture(1, tunnelTexture2);
        }
        else
        // Switch fog on/off
        if (tnlMode == TOGGLE_FOG)
        {
            if (!m_fogOn)
            {
                ap.setFog(tunnelFog);
                m_fogOn = true;
            }
            else
            {
                ap.setFog(null);
                m_fogOn = false;
            }
        }
    }

    // Picks some cameras etc
    private void preInitPondScene()
    {
        //
        World pond = m_scenes[SCENE_POND];

        // Default to first camera
        Camera c = (Camera) pond.find(UID_POND_CAMERA1);
        c.setPerspective(m_cameraFOVs[0], 1.0f, 0.1f,5);

        //
        m_currentCamera = 0;
        pond.setActiveCamera(c);

        // Target camera to the ant. Note that the y target axis is scene's z-axis because 
        // the scene is exported from 3dsmax, in which z points up on world space
        
        Node n = (Node) pond.find(UID_POND_ANTHEAD);
        c.setAlignment(n, Node.ORIGIN, pond, Node.Z_AXIS);
        c.scale(-1, 1, -1);

        // Set field-of-view and clip params by hand
        c = (Camera) pond.find(UID_POND_CAMERA2);
        c.setPerspective(m_cameraFOVs[1], 1.0f, 0.1f,5);

        c.setAlignment(n, Node.ORIGIN, pond, Node.Z_AXIS);
        c.scale(-1, 1, -1);

        c = (Camera) pond.find(UID_POND_CAMERA3);
        c.setPerspective(m_cameraFOVs[2], 1.0f, 0.1f,5);

        c.setAlignment(n, Node.ORIGIN, pond, Node.Z_AXIS);
        c.scale(-1, 1, -1);

        c = (Camera) pond.find(UID_POND_CAMERA4);
        c.setPerspective(m_cameraFOVs[3], 1.0f, 0.1f,5);

        c.setAlignment(n, Node.ORIGIN, pond, Node.Z_AXIS);
        c.scale(-1, 1, -1);
    }

    // Inits some snowflakes for the Nokia scene
    private void initSnowFlakes()
    {
        // First we init a vertex array with 3 components (X,Y,Z), size of each component is byte
        flakeVertexArray = new VertexArray(flakeVertices.length / 3, 3, 2);

        // Now, we copy the actual XYZ coordinates to the array
        flakeVertexArray.set(0, flakeVertices.length / 3, flakeVertices);

        // Init a texture coordinate array with same size as the coordinate array, but only two coords for each vertex (u,v)
        flakeTextureArray = new VertexArray(flakeTexCoords.length / 2, 2, 2);

        // Copy actual values again
        flakeTextureArray.set(0, flakeTexCoords.length / 2, flakeTexCoords);

        // Next we need to create a vertex buffer, to which we'll assign the texture coordinates and XYZ coordinates
        flakeVertexBuffer = new VertexBuffer();

        // No scale, no bias in XYZ coordinates
        flakeVertexBuffer.setPositions(flakeVertexArray, 0.01f, null);

        // Assign texture coordinates to first texture unit. Again, no scale & no bias is needed
        flakeVertexBuffer.setTexCoords(0, flakeTextureArray, 0.1f, null);

        // Next we need to create a triangle strip array which holds the polygon definitions for the flakes
        flakeTriangles = new TriangleStripArray(flakeStrip, flakeStripLengths);

        /** 
        *
        * We could also create the triangle strip implicitly, by defining the first vertex index as zero..
        * This saves some space when simple, continuous triangle strips are created.
        *
        * flakeTriangles = new TriangleStripArray(0, flakeStripLengths);
        *
        */



        // First we need to create new appearance
        flakeAppearance = new Appearance();

        // Then we load a texture image ... We need to use alpha due to transparent pixels
        flakeTextureImage = new Image2D(Image2D.RGBA, platformServices.loadImage("nokia/snowflake.png"));

        // Then we create a texture map from the image
        flakeTexture = new Texture2D(flakeTextureImage);

        // Choose worst possible filtering type to gain more speed (actually it's already selected by default)
        flakeTexture.setFiltering(Texture2D.FILTER_BASE_LEVEL, Texture2D.FILTER_NEAREST);

        // Just replace the texel directly with the source for more speed
        flakeTexture.setBlending(Texture2D.FUNC_REPLACE);




        // Next, create a polygon mode definition
        flakePolyMode = new PolygonMode();

        // No, we don't need perspective correction for such small polygons
        flakePolyMode.setPerspectiveCorrectionEnable(false);

        // Shading should apply to whole polygon
        flakePolyMode.setShading(PolygonMode.SHADE_FLAT);

        // Disable visible side culling (both sides of flakes are seen)
        flakePolyMode.setCulling(PolygonMode.CULL_NONE);

        // Define winding as clockwise (actually it doesn't matter here since no culling is used...)
        flakePolyMode.setWinding(PolygonMode.WINDING_CW);

        // No, we don't want the flakes to be lit by camera light
        flakePolyMode.setLocalCameraLightingEnable(false);

        // Sincle no culling is used, we need to light both sides of the polygon
        flakePolyMode.setTwoSidedLightingEnable(true);




        // Let's define how the polygon is blended with the background
        flakeCompositing = new CompositingMode();

        // We want to use the alpha to blend the pixels to background
        flakeCompositing.setBlending(CompositingMode.ALPHA);

        // Don't write anything to alpha buffer
        flakeCompositing.setAlphaWriteEnable(false);




        // Set the texture map to the appearance's first texture unit
        flakeAppearance.setTexture(0, flakeTexture);

        // Assign the polygon mode to the appearance
        flakeAppearance.setPolygonMode(flakePolyMode);

        // Assign the compositing mode to the appearance
        flakeAppearance.setCompositingMode(flakeCompositing);



        // Get the world..
        World nokia = m_scenes[SCENE_NOKIA];

        // Finally, let's do some meshes from these definitions and add them to the scene
        m_snowFlakes = new Mesh[NUM_SNOWFLAKES];

        //
        for (int a = 0; a < NUM_SNOWFLAKES; a++)
        {
            m_snowFlakes[a] = new Mesh(flakeVertexBuffer, flakeTriangles, flakeAppearance);
            m_snowFlakes[a].translate(
                rnd(-SNOWFLAKE_SCALE, SNOWFLAKE_SCALE),
                rnd(-SNOWFLAKE_SCALE, SNOWFLAKE_SCALE),
                rnd(GROUND_LEVEL, GROUND_LEVEL + (SNOWFLAKE_SCALE/2.0f))
            );
            nokia.addChild(m_snowFlakes[a]);
        }
    }

    //
    private float rnd(float min, float max)
    {
        float p = (float) (m_random.nextInt() & 0xFFF) / 4095.0f;
        float q = 1.0f - p;
        return p * max + q * min;
    }

    // Animates the snowflakes...
    private void animateSnowFlakes(int time)
    {
        float[] xyz = new float[3];
        for (int a = 0; a < NUM_SNOWFLAKES; a++)
        {
            // push the new position to the flake. Note that the scene is exported from 3dsmax, thus z points up.
            m_snowFlakes[a].translate(0,0, -0.1f);

            // get current snowflake position
            m_snowFlakes[a].getTranslation(xyz);

            // move the flakes a bit
            if (xyz[2] < GROUND_LEVEL)
            {
                // push the new position to the flake
                m_snowFlakes[a].translate(0,0, SNOWFLAKE_SCALE/2.0f);
            }
        }
    }


    // Definitions for a snowflake
    private Appearance          flakeAppearance;
    private Material            flakeMaterial;
    private PolygonMode         flakePolyMode;
    private CompositingMode     flakeCompositing;
    private Image2D             flakeTextureImage;
    private Texture2D           flakeTexture;

    // Arrays & buffers for snowflake
    private VertexArray         flakeVertexArray;
    private VertexArray         flakeTextureArray;
    private VertexBuffer        flakeVertexBuffer;
    private TriangleStripArray  flakeTriangles;

    // Meshes
    private Mesh[]              m_snowFlakes;

    // Vertex coordinates for a snowflake (a simple flat quad actually)
    private static final short flakeVertices[] =
    {
        (short) -10, (short) 0, (short)  10,
        (short) -10, (short) 0, (short) -10,
        (short)  10, (short) 0, (short)  10,
        (short)  10, (short) 0, (short) -10
    };

    // Texture coordinates for the snowflake
    private static final short flakeTexCoords[] =
    {
        (short) 0,  (short) 10,
        (short) 0, (short) 0,
        (short) 10, (short) 10,
        (short) 10,  (short) 0,
    };

    // Strip lengths for a simple snowflake
    private static final int flakeStripLengths[] = { 4 };

    // Triangle strip for the snowflake
    private static final int flakeStrip[] =
    {
        0, 1, 2, 3
    };

    //
    private Appearance          tunnelAppearance;
    //private Image2D           tunnelTextureImage1;
    private Image2D             tunnelTextureImage2;

    //
    private Fog                 tunnelFog;

    //
    private Texture2D           tunnelTexture1;
    private Texture2D           tunnelTexture2;

    // Arrays & buffers for the tunnel
    private VertexArray         tunnelTextureArray;

    // Texture coordinates for the tunnel
    private short[] tunnelTexCoords;
}