Ô̗ɕ\ʂtACgĂĂ vOLightGoAround.java܂B ƂȂ郉CgJavajava.util.TimergŋԂ̒]܂B

ȉǂẴ\[XR[hĂ܂B

ύXAlje

O͂̃vOɈȉ̗vfύXAljĂ܂B

• CubeNX: O͂Ɠ̂ł邪A͕\ʂ`A ̔ˋ߂ގ(Material)߂Ă
• LightNX: \NXBCameraNXlAupdate\bh OpenGL̃Cg̐ݒs
• java.util.Timer̗p: LightIuWFNg莞ԂƂɈړ邽߂ɗp

ȊO̗vfAN@AJA\AL[Ȃǂ͑O͂ƓR[hɂȂĂ܂B

Cube NX: ̂̕\ʂ`

Cube NXĂ݂܂傤B

class Cube extends Material {
    public Cube() {
        super(0, 0, 0);
    }
    
    private double width = 2d;
    
    private double[][] vertexList = {
        { -1, -1, -1},
        { +1, -1, -1},
        { +1, +1, -1},
        { -1, +1, -1},
        { -1, -1, +1},
        { +1, -1, +1},
        { +1, +1, +1},
        { -1, +1, +1},
    };
    
    private int[][] faceList = {
        {0, 3, 2, 1},
        {1, 2, 6, 5},
        {5, 6, 7, 4},
        {4, 7, 3, 0},
        {4, 0, 1, 5},
        {3, 7, 6, 2},
    };
    
    private double[][] normalList = {
        {0.0, 0.0, -1.0},
        {1.0, 0.0, 0.0},
        {0.0, 0.0, 1.0},
        {-1.0, 0.0, 0.0},
        {0.0, -1.0, 0.0},
        {0.0, 1.0, 0.0},
    };
    
    float[] color = { 1.0f, 0.1f, 0.1f, 1.0f };
    float[] diffuse = { 0.8f, 0.8f, 0.8f, 1.0f };
    float[] specular = { 0.0f, 0.0f, 0.0f, 1.0f };
    float[] ambient = { 0.2f, 0.2f, 0.2f, 1.0f };
    float[] emission = { 0.0f, 0.0f, 0.0f, 1.0f };
    float shininess = 0.0f;
    
    public void update(GLGraphics g) {
        g.glTranslated(getX(), getY(), getZ());
        g.glScaled(width, width, width);
        g.glMaterialfv(GLConstants.GL_FRONT, GLConstants.GL_DIFFUSE, color);
        g.glMaterialfv(GLConstants.GL_FRONT, GLConstants.GL_AMBIENT, color);
        g.glMaterialfv(GLConstants.GL_FRONT, GLConstants.GL_SPECULAR, specular);
        g.glMaterialfv(GLConstants.GL_FRONT, GLConstants.GL_EMISSION, emission);
        g.glMaterialf(GLConstants.GL_FRONT, GLConstants.GL_SHININESS, shininess);
        
        g.glBegin(GLConstants.GL_QUADS);
        for (int i = 0; i < faceList.length; i++) {
            int[] face = faceList[i];
            g.glNormal3dv(normalList[i]);
            for (int j = 0; j < face.length; j++) {
                int vertexIndex = face[j];
                g.glVertex3dv(vertexList[vertexIndex]);
            }
        }
        g.glEnd();
    }
    
    public String toString() {
        return "Cube at: (" + getX() + "," + getY() + "," + getZ() + ") width: " + width;
    }
}

Wϊ̗p

O͗̂`̂ɒ_̍WڌvZāAglVertex3dvőł݂܂B ͒ڍWvZ܂B܂Č_ƃXP[ςĂ΁A _ɑ傫Œ̗̂Ƃœ̂܂B

܂AglTranslatedŌ_̈ʒuݒ肵 ʒuɎĂ܂B glScaledő傫eW g債܂(̏ԂōsKv܂)B ɂAPvertexList ŗ̂`悷邱ƂŁAOƓʒuA傫̗̂ `悷邱Ƃł܂B

˂̐ݒ

ɁA(̕\)̍ގglMaterialŌ߂܂B ͌˂̏@A‚܂ǂFŕ\邩ݒ肵Ă܂B ƈႢglColor͗p܂B

łGL_DIFFUSE(gU) GL_AMBIENT(‹) s̐ԂłcolorZbgĂ܂B ŔΐԂ\邱ƂɂȂ܂B

̑glMaterialݒOpenGL̃ftHglƁA ̃ftHglݒ肵Ă邾̂̂ł(‚܂AĂ)B GL_SPECULAR(ʔ)A GL_EMISSION(F)A GL_SHININESS(ˋx)܂B ڂOpenGL̃}jAB

̂̕`

x͗̂̂ɐł͂ȂAʂ`܂B GL_QUADS͎lp̕ʂ`܂B ܂Aeʂɑ΂glNormal3dvɂ ʂɐȖ@xNgeʂɎ蓮Őݒ肷Kv܂B OpenGL̖ʂɂ͕\ʂƗʂ܂B ftHgł́A@xNǧĔvɓ_łĂ ̖ʂ\ʁAtɎvɑłĂΗʂɂȂ܂B

@xNgfaceListɑΉʂ̖@ nomalList ł炩ߐݒ肵Ă܂B

Light NX: ̐ݒ

̂̍ގݒ肵ĂĂ΁AFt܂B oCgALightNX܂B܂ALightNX ^C}[ɂĉ]邽߂ rotate \bh‚悤ɂ܂B

class Light extends Material {
    public Light() {
        super(10, 10, 0);
    }

    private int index;
    private double radius = 10;
    private double angle = 0;
    private float[] ambient = {0.0f, 0.0f, 0.0f, 1.0f};
    private float[] diffuse = {1.0f, 1.0f, 1.0f, 1.0f};
    private float[] specular = {1.0f, 1.0f, 1.0f, 1.0f};
    
    public void update(GLGraphics g) {
        g.glLightModeli(GLConstants.GL_LIGHT_MODEL_TWO_SIDE, 1);
        int light = GLConstants.GL_LIGHT0;
        g.glLightfv(light, GLConstants.GL_AMBIENT, ambient);
        g.glLightfv(light, GLConstants.GL_DIFFUSE, diffuse);
        g.glLightfv(light, GLConstants.GL_SPECULAR, specular);
        g.glLightfv(light, GLConstants.GL_POSITION, new float[]{getX(), getY(), getZ(), 1f});
        g.glEnable(light);
    }
    
    public void rotate() {
        angle += getSpeed();
        setX((int) (radius * Math.cos(Math.toRadians(angle))));
        setZ((int) (radius * Math.sin(Math.toRadians(angle))));
    }
    
}

Cg̐ݒ

CgGL_LIGHT0`GL_LIGHT7܂ŒuƂ”\ŁAł GL_LIGHT0g܂B Cg̃ftHgЖʂoȂ̂ŁA glLightModeli(GL_LIGHT_MODEL_TWOSIDE, 1) ŗʂo悤ɂĂ܂B ̖̂ʓlAɂGL_AMBIENTA GL_DIFFUSEA GL_SPECULAR ݒ肵܂B̐ݒ͔F̌̐ݒłB

GL_POSITIONŃCg3̈ʒuݒ肵܂B ŌglEnableɂ GL_LIGHT0LĂ܂B

ۂLightIuWFNg͂̂悤ɌĂ΂܂B CApplicationupdate\bḧꕔ:

            g.glClear(GLConstants.GL_COLOR_BUFFER_BIT | GLConstants.GL_DEPTH_BUFFER_BIT);
            
            g.glPushMatrix();
            int[] enables = {
                GLConstants.GL_DEPTH_TEST,
                GLConstants.GL_LIGHTING,
                GLConstants.GL_CULL_FACE,
            };
            for (int i = 0; i < enables.length; i++) {
                g.glEnable(enables[i]);
            }
            g.glMatrixMode(GLConstants.GL_PROJECTION);
            g.glLoadIdentity();
            camera.update(g);
            g.glMatrixMode(GLConstants.GL_MODELVIEW);
            g.glLoadIdentity();
            g.glPushMatrix();
            light.update(g);
            g.glPopMatrix();
            for (int i = 0; i < materials.length; i++) {
                g.glPushMatrix();
                materials[i].update(g);
                g.glPopMatrix();
            }
            for (int i = enables.length - 1; i >= 0; i--) {
                g.glDisable(enables[i]);
            }
            g.glPopMatrix();

͂߂glClearłGL_DEPTH_BUFFER_BIT NA悤ɂ܂Bɂ闧̕\L邽߂ɁA GL_DEPTH_TESTA GL_LIGHTINGA GL_CULL_FACE ȂǂLĂ܂B Ĉȉ̏ɐݒsƂŕ`悳܂B

1. J̐ݒ
2. Cg̐ݒ
3. ̂̕`

]̂߂rotate\bh

rotate \bh͒PɋOʼn]Ƃ̈ʒuVɃZbgĂ邾łB ł͕`֌W͉̏s܂B

}`XbhŌĂяo郁\bhł͒PɌvZf[^̍XVsA `֌W̃\bh͌Ăт܂B`̍XVApplication update \bhōsA̒ōXVꂽf[^p܂B

java.util.Timer ̗p: 莞ԂƂ̍XV

java.util.Timerjava.util.TimerTaskIuWFNgrun \bh莞ԌɌĂяoAJԂĂяo‚Âł܂B pLightIuWFNgOʼn]鏈ĂяoĂ܂B

ApplicationNX̃RXgN^:

    private Timer timer;
    private Object monitor = new Object();
    
    public LightGoAround() {
        font = new SystemFont(new Font("System", Font.PLAIN, fontSize));
        camera = new Camera(width / (double) height, 10, cube1);
        light = new Light();
        
        timer = new Timer(true);
        timer.schedule(new TimerTask() {
            public void run() {
                synchronized (monitor) {
                    light.rotate();
                }
            }
        }, 0, 10);
        
        materials = new Material[] {
            cube1,
            cube2,
        };
    }

Timer NX̃RXgN^̈daemonXbhœƂݒłB schedule\bh͂‚A ̏ꍇ́uTimerTask0~bォA10~bƂɌĂяo‚Âv 郁\bhłBTimerTaskrun\bh PLightIuWFNgrotate\bhĂяoĂ邾łB

TimerTask̒łmonitorIuWFNgsynchronized ubNň͂܂Ă܂Bupdate\bhł悤 monitorIuWFNgsynchronizedubNň͂ł܂B

    public void update(GLGraphics g) {
        synchronized (monitor) {
            g.glClear(GLConstants.GL_COLOR_BUFFER_BIT | GLConstants.GL_DEPTH_BUFFER_BIT);
            ...
        }
    }

Timerupdate ʂ̃XbhŌĂяo邽߁A ̃\bhsɂ̃\bhĂяoȂ悤ɂ邽߂ɍsĂ܂B

p: CtQ[

ȏA^C}[pCtQ[̃\[XR[hLife.javałB

Copyright © 2001-2002 CyberStep, Inc. All Rights Reserved.

Oni \tgEFA