0

今後のプロジェクトで使用するために、独自のシンプルなゲームエンジンを作成しています。基本クラスRenderObjectを拡張する一連のオブジェクトを格納するワールドオブジェクトがあります。

RenderObjectには、スケール回転位置の滑らかなシェーディングなどが含まれ、すべての拡張クラスに独自のメソッドrender()を実装するように強制します。

私の世界をナビゲートするために、FPSスタイルのカメラコントロールセットアップがあります。これは、system.out.println()を介してテストし、ピッチとヨーをチェックして、正しく機能しています。

ただし、どのオブジェクトもレンダリングされていません。私のワールドオブジェクトには、ワールド内のすべてのオブジェクトを循環し、それらのrender()関数を呼び出すrenderObjects()というメソッドがあります。 修正済み-新しい問題...特定の場所でランダムに飛び回る4つの2x2ピクセルドットを取得しています。次に、マウスを動かすと、クラスター全体が移動します。ゲームごとにonUpdate()メソッドが呼び出され、lookThrough()が呼び出されます。

FPSCameraControl.java

public class FPSCameraControl
{
    private boolean DEBUG = false;

    public Vector3f position = null;
    public float yaw = 0.0f;
    public float pitch = 0.0f;

    public FPSCameraControl(float x, float y, float z)
    {
        position = new Vector3f(x, y, z);
    }
    public void yaw_(float amount)
    {
        yaw -= amount;
        if(yaw>360){
            yaw=0+(yaw-360);
        }
        if(yaw<1){
            yaw=360-(1-yaw);
        }
    }
    public void pitch_(float amount)
    {
        pitch -= amount;
        if(pitch>=155)
        {
            pitch=155;
        }
        if(pitch<=25)
        {
            pitch=25;
        }
    }
    public void walkForward(float distance)
    {
        position.x -= -distance * (float)Math.sin(Math.toRadians(yaw));
        position.z += -distance * (float)Math.cos(Math.toRadians(yaw));
    }
    public void walkBackwards(float distance)
    {
        position.x += -distance * (float)Math.sin(Math.toRadians(yaw));
        position.z -= -distance * (float)Math.cos(Math.toRadians(yaw));
    }
    public void strafeLeft(float distance)
    {
        position.x -= distance * (float)Math.sin(Math.toRadians(yaw-90));
        position.z += distance * (float)Math.cos(Math.toRadians(yaw-90));
    }
    public void strafeRight(float distance)
    {
        position.x -= distance * (float)Math.sin(Math.toRadians(yaw+90));
        position.z += distance * (float)Math.cos(Math.toRadians(yaw+90));
    }
    public void lookThrough()
    {
        GL11.glRotatef(pitch, 1.0f, 0.0f, 0.0f);
        GL11.glRotatef(yaw, 0.0f, 1.0f, 0.0f);
        GL11.glTranslatef(position.x, position.y, position.z);
    }
    public void onUpdate()
    {
        debug("Updating View");

        //Calculate Sensitivity

        float sen = (0.02F*10);

        debug("Sensitivity: " + sen);

        //Get Center Of Screen

        int cx = Display.getDisplayMode().getWidth()/2;
        int cy = Display.getDisplayMode().getHeight()/2;

        //Get Mouse Position From Center

        int x = Mouse.getX()-cx;
        int y = Mouse.getY()-cy;

        debug("Mouse Moved: " + x + ", " + y);

        //Apply Inverting If Set



        //Apply Sensitivity

        float _yaw = (x*sen);
        float _pitch = (y*sen);

        yaw_(_yaw);
        pitch_(_pitch);

        debug("New Yaw: " + yaw);
        debug("New Pitch: " + pitch);

        UpdatePosition();

        //SET MOUSE TO CENTER

        Mouse.setCursorPosition(cx, cy);

        lookThrough();
    }
    public void printROT()
    {
        System.out.println("Pitch : "+pitch);
        System.out.println("Yaw : "+yaw);
        System.out.println();
        System.out.println("XYZ : "+position.x+", "+position.y+", "+position.z);
    }

    public void debug(String msg)
    {
        if(DEBUG)
        {
            System.out.println(msg);
        }
    }

    public void UpdatePosition()
    {
        float f=0;
        float b=0;
        float r=0;
        float l=0;
        boolean moved =false;
        boolean shift = Keyboard.isKeyDown(Keyboard.KEY_LSHIFT);
        if(Keyboard.isKeyDown(Keyboard.KEY_W))
        {
            if(shift)
            {
                f=0.04F;
            }
            else
            {
                f=0.02F;
            }
            moved=true;
        }
        if(Keyboard.isKeyDown(Keyboard.KEY_S))
        {
            if(shift)
            {
                b=0.04F;
            }
            else
            {
                b=0.02F;
            }
            moved=true;
        }
        if(Keyboard.isKeyDown(Keyboard.KEY_D))
        {
            if(shift)
            {
                r=0.025F;
            }
            else
            {
                r=0.016F;
            }
            moved=true;
        }
        if(Keyboard.isKeyDown(Keyboard.KEY_A))
        {
            if(shift)
            {
                l=0.02F;
            }
            else
            {
                l=0.016F;
            }
            moved=true;
        }
        if(moved)
        {
            walkForward(f);
            walkBackwards(b);
            strafeLeft(l);
            strafeRight(r);
        }
    }
}

RenderObject.java

public abstract class RenderObject
{
    public  double []  location  =  new  double [] {0, 0, 0};
    public  double []  rotation  =  new  double [] {0, 0, 0};
    public  double []     scale  =  new  double [] {1, 1, 1};
    public Color color = new Color(180, 180, 180);

    public boolean smooth = false;

    public RenderObject parent = null;
    public LinkedList<RenderObject> children = new LinkedList<RenderObject>();

    public abstract void render();

    public void setScale(double x, double y, double z)
    {
        scale = new double[]{x, y, z};
    }

    public void setParent(RenderObject object)
    {
        parent = object;
    }
    public void removeParent()
    {
        parent = null;
    }
    public RenderObject getParent()
    {
        return parent;
    }
    public void addChild(RenderObject object)
    {
        object.setParent(this);
        children.add(object);
    }
    public void removeChild(RenderObject object)
    {
        if(children.contains(object))
        {
            object.removeParent();
            children.remove(object);
        }
    }
}

そしてRenderCube.java

public class RenderCube extends RenderObject
{
    @Override
    public void render()
    {
        if(smooth)
        {
            GL11.glShadeModel(GL11.GL_SMOOTH);
        }
        else
        {
            GL11.glShadeModel(GL11.GL_FLAT);
        }
        GL11.glBegin(GL11.GL_QUADS);

        GL11.glPushMatrix();

        GL11.glColor3b( color.getRedByte(),color.getGreenByte(), color.getBlueByte() );

        GL11.glRotated(rotation[0], 1.0, 0.0, 0.0);
        GL11.glRotated(rotation[1], 0.0, 1.0, 0.0);
        GL11.glRotated(rotation[2], 0.0, 0.0, 1.0);

        //TOP
        GL11.glNormal3d(0.0, 1.0, 0.0);
        GL11.glVertex3d(location[0]-scale[0], location[1]+scale[1], location[2]-scale[2]);
        GL11.glVertex3d(location[0]-scale[0], location[1]+scale[1], location[2]+scale[2]);
        GL11.glVertex3d(location[0]+scale[0], location[1]+scale[1], location[2]+scale[2]);
        GL11.glVertex3d(location[0]+scale[0], location[1]+scale[1], location[2]-scale[2]);

        //BOTTOM
        GL11.glNormal3d(0.0, -1.0, 0.0);
        GL11.glVertex3d(location[0]-scale[0], location[1]-scale[1], location[2]-scale[2]);
        GL11.glVertex3d(location[0]-scale[0], location[1]-scale[1], location[2]+scale[2]);
        GL11.glVertex3d(location[0]+scale[0], location[1]-scale[1], location[2]+scale[2]);
        GL11.glVertex3d(location[0]+scale[0], location[1]-scale[1], location[2]-scale[2]);

        //FRONT
        GL11.glNormal3d(0.0, 0.0, 1.0);
        GL11.glVertex3d(location[0]-scale[0], location[1]+scale[1], location[2]+scale[2]);
        GL11.glVertex3d(location[0]+scale[0], location[1]+scale[1], location[2]+scale[2]);
        GL11.glVertex3d(location[0]+scale[0], location[1]-scale[1], location[2]+scale[2]);
        GL11.glVertex3d(location[0]-scale[0], location[1]-scale[1], location[2]+scale[2]);

        //BACK
        GL11.glNormal3d(0.0, 0.0, -1.0);
        GL11.glVertex3d(location[0]-scale[0], location[1]+scale[1], location[2]-scale[2]);
        GL11.glVertex3d(location[0]+scale[0], location[1]+scale[1], location[2]-scale[2]);
        GL11.glVertex3d(location[0]+scale[0], location[1]-scale[1], location[2]-scale[2]);
        GL11.glVertex3d(location[0]-scale[0], location[1]-scale[1], location[2]-scale[2]);

        //RIGHT
        GL11.glNormal3d(1.0, 0.0, 0.0);
        GL11.glVertex3d(location[0]+scale[0], location[1]+scale[1], location[2]+scale[2]);
        GL11.glVertex3d(location[0]+scale[0], location[1]+scale[1], location[2]-scale[2]);
        GL11.glVertex3d(location[0]+scale[0], location[1]-scale[1], location[2]-scale[2]);
        GL11.glVertex3d(location[0]+scale[0], location[1]-scale[1], location[2]+scale[2]);

        //LEFT
        GL11.glNormal3d(-1.0, 0.0, 0.0);
        GL11.glVertex3d(location[0]-scale[0], location[1]+scale[1], location[2]+scale[2]);
        GL11.glVertex3d(location[0]-scale[0], location[1]+scale[1], location[2]-scale[2]);
        GL11.glVertex3d(location[0]-scale[0], location[1]-scale[1], location[2]-scale[2]);
        GL11.glVertex3d(location[0]-scale[0], location[1]-scale[1], location[2]+scale[2]);

        Color _color = new Color(180, 180, 180);

        GL11.glColor3b( _color.getRedByte(),_color.getGreenByte(), _color.getBlueByte() );

        GL11.glPopMatrix();

        GL11.glEnd();
    }
}

誰かが機能していない可能性があるものを見ていますか?私はしません。

4

1 に答える 1

0

何もレンダリングされていませんでした。

追加したとき:

GL11.glMatrixMode(GL11.GL_PROJECTION);
GL11.glLoadIdentity();
GL11.glOrtho(-500, 500, -281, 281, -1, 1);
GL11.glMatrixMode(GL11.GL_MODELVIEW); 

レンダリングを開始しましたが、この時点で正投影ビューでレンダリングしているという事実については考えていませんでした。私はそれを次のように置き換えました:

GL11.glMatrixMode(GL11.GL_PROJECTION);
GL11.glLoadIdentity();      
GLU.gluPerspective(45.0f, ((float) 800) / ((float) 600), 0.1f, 100.0f);
GL11.glMatrixMode(GL11.GL_MODELVIEW);
GL11.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);

そして、シーンは完全にレンダリングされました。しかし、私のカメラはまだ少し乱雑ですが、これは私のエンジンが今のところ正しく機能していることを証明しています。カメラはエンジンの一部ではなく、私がテスト用に作成したものなので、「エンジン」は正しく機能しています。

簡単にするために、WorldにCameraオブジェクトを含めます。これは、表示位置、角度、FoVなどを制御します。

助けてくれてありがとう@pwny-あなたは助けてくれました、ただの簡単な変更です。

于 2012-05-30T19:51:17.927 に答える