spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Supermoderator

21.07.2010, 12:51

Eben!

Ambient meinte ich nicht, sondern die Farbe bei Clear.
Kannst du den gesamten Code vielleicht mal irgendwo posten?

fka tm

Zum Seitenanfang

Alter Hase

Beruf: Student

21.07.2010, 13:17

1. Welche Auswirkungen hat den die Farbe, die Man bei Clear angeben muss eigentlich?
2. Brauchst du nur die Vollständige Pin- und Intro-Klasse oder auch noch die VierGewinnt-Klasse? (Ich habe das Spiel wie bei Breakanoid aufgebaut!)

Zum Seitenanfang

Supermoderator

21.07.2010, 13:25

1. Keine, eigentlich. Hintergrundfarbe halt.

Außer, dass du siehst, ob dein Programm auch brav rendert.

2. Eigentlich alles. Hierher zum Beispiel: file-upload.net

fka tm

Zum Seitenanfang

Alter Hase

Beruf: Student

21.07.2010, 13:55

Schon mal Danke!
Ich habe mal die Farbe bei Clear auf weiß geändert und man kann tatsächlich am oberen Bildrand einen Pin flimmern sehen. Allerdings flimmert der Pin nur und wenn ich das Levelmodell dann auch noch rendern will startet das Programm wieder nicht richtig!
Deshalb habe ich auch mal die Model.tbm Datei als Zip-Archiv hochgeladen. Versuch mal bitte, ob du sie rendern kannst!
Außerdem bitte ich dich, dir mal meinen vollständigen Code der Pin- und Intro-Klasse anzugucken! Die VierGewinnt Klasse hielt ich jetzt für nich so wichtig, da sie nur ein paar Sachen lädt, die nich für das Intro relevant sind und dann halt in der Nachrichtenschleife die Render und Move Funktionen vom Intro aufruft!

Hier ist der Code:

C-/C++-Quelltext

//Intro.h

#ifndef _INTRO_INC_
#define _INTRO_INC_

class CIntro{
public:
    CIntro();
    ~CIntro();
    tbResult Init();
    tbResult Load();
    tbResult Unload();
    tbResult Exit();
    tbResult Move(float fTime);
    tbResult Render(float fTime);

    //vergangene Zeit seit Zustandsbeginn
    float m_fTime;

    //Das Levelmodel
    tbModel m_vLevelModel;
};

#endif

//Intro.cpp

#include "VierGewinnt.h"

CIntro::CIntro(){}

CIntro::~CIntro(){}

tbResult CIntro::Init(){
    TB_INFO("Initalisiere das Intro!");

    //Direct3D
    tbDirect3D &D3D = tbDirect3D::Instance();

    //CPin
    CPin &Pin = CPin::Instance();

    //Zeit Variable auf Null setzen
    m_fTimeSEnd = 0.0f;

    //Weltmatrix setzen
    tbMatrix mWorld = tbMatrixTranslation(tbVector3(0.0f, 0.0f, 0.0f));
    D3D.SetTransform(D3DTS_WORLD, mWorld);

    //Sichtmatrix setzen
    tbMatrix mView = tbMatrixTranslation(tbVector3(0.0f, 2.0f, -3.0f));
    D3D.SetTransform(D3DTS_VIEW, mView);

    //Modelle laden
    if(Load()){
        return TB_ERROR;
    }
    
    //Pins initalisieren
    int Pos;
    Pos = CPin::Instance().GetNextFreePlace();
    m_dEndPinPos[0] = Pos;
    Pin.AddPin(Pos,5,1);
    Pin.SetColor(Pos, FALSE);
    Pos = Pin.GetNextFreePlace();
    Pin.AddPin(Pos,5,2);
    Pin.SetColor(Pos, FALSE);
    Pos = Pin.GetNextFreePlace();
    Pin.AddPin(Pos,5,3);
    Pin.SetColor(Pos, TRUE);
    Pos = Pin.GetNextFreePlace();
    Pin.AddPin(Pos,5,4);
    Pin.SetColor(Pos, TRUE);
    Pos = Pin.GetNextFreePlace();
    Pin.AddPin(Pos,5,5);
    Pin.SetColor(Pos, TRUE);
    Pos = Pin.GetNextFreePlace();
    Pin.AddPin(Pos,5,6);
    Pin.SetColor(Pos, FALSE);
    m_dEndPinPos[1] = Pos;
    Pos = Pin.GetNextFreePlace();
    Pin.AddPin(Pos,4,2);
    Pin.SetColor(Pos, FALSE);
    Pos = Pin.GetNextFreePlace();
    Pin.AddPin(Pos,4,3);
    Pin.SetColor(Pos, TRUE);
    Pos = Pin.GetNextFreePlace();
    Pin.AddPin(Pos,4,4);
    Pin.SetColor(Pos, TRUE);
    Pos = Pin.GetNextFreePlace();
    Pin.AddPin(Pos,4,5);
    Pin.SetColor(Pos, FALSE);
    m_dEndPinPos[2] = Pos;
    Pos = Pin.GetNextFreePlace();
    Pin.AddPin(Pos,3,3);
    Pin.SetColor(Pos, FALSE);
    Pos = Pin.GetNextFreePlace();
    Pin.AddPin(Pos,3,4);
    Pin.SetColor(Pos, TRUE);
    m_dStartPinPos = Pin.GetNextFreePlace();
    m_dEndPinPos[3] = Pos;
    Pin.AddPin(m_dStartPinPos,0,0);
    Pin.SetColor(m_dStartPinPos, FALSE);
    Pin.SetPosition(m_dStartPinPos,2,4,FALSE);

    TB_INFO("Initalisierung des Intros beendet!");

    return TB_OK;
}

tbResult CIntro::Load(){
    //Modelle laden
    if(m_vLevelModel.Init("Model.tbm")){
        //Fehler!
        TB_ERROR("Das Levelmodel konnte nicht geladen werden!", TB_ERROR);
    }

    return TB_OK;
}

tbResult CIntro::Unload(){
    //Modelle entladen
    if(m_vLevelModel.Exit()){
        //Fehler!
        TB_ERROR("Das Levelmodel konnte nicht entladen werden!", TB_ERROR);
    }

    return TB_OK;
}

tbResult CIntro::Exit(){
    //Modelle entladen
    return Unload();
}

tbResult CIntro::Move(float fTime){
    m_fTime+=fTime;

    CPin::Instance().Move(fTime);

    return TB_OK;
}

tbResult CIntro::Render(float fTime){
    //Direct3D
    tbDirect3D &D3D = tbDirect3D::Instance();

    //Es Gibt ein Lichter
    D3DLIGHT9 m_pLight;

    //Material
    D3DMATERIAL9 xMaterial;

        D3D->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, tbColor(1.0f), 1.0f, 0);
    D3D->BeginScene();

    //Sichtmatrix setzen
        tbMatrix mView = tbMatrixTranslation(tbVector3(0.0f, 2.0f, -3.0f)) * tbMatrixRotationY(90.0f * m_fTime);
    D3D.SetTransform(D3DTS_VIEW, mView);

    // Die Projektionsmatrix erzeugen und einsetzen.
        tbMatrix mProjection = tbMatrixProjection(TB_DEG_TO_RAD(70.0f), 
        tbDirect3D::Instance().GetAspect(), 0.1f, 100.0f);
        tbDirect3D::Instance()->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)(&mProjection));

    //Sichtmatrix setzen
    tbMatrix mWorld = tbMatrixTranslation(tbVector3(0.0f, 0.0f, 0.0f));
    D3D.SetTransform(D3DTS_WORLD, mWorld);

    // Render-States
    D3D.SetRS(D3DRS_FILLMODE, D3DFILL_SOLID);
    D3D.SetRS(D3DRS_AMBIENT, tbColor(1.0f, 1.0f, 1.0f));
    D3D.SetRS(D3DRS_LIGHTING, TRUE);
    D3D.SetRS(D3DRS_CULLMODE, D3DCULL_NONE);
    D3D.SetRS(D3DRS_ZENABLE, TRUE);
    D3D.SetRS(D3DRS_ZWRITEENABLE, TRUE);
    D3D.Capture();

    ZeroMemory(&m_pLight, sizeof(D3DLIGHT9));
    m_pLight.Type = D3DLIGHT_POINT;
    m_pLight.Diffuse = tbColor(1.0f, 1.0f, 1.0f);
    m_pLight.Ambient = tbColor(1.0f, 1.0f, 1.0f);
    m_pLight.Specular = tbColor(1.0f, 1.0f, 1.0f);

    m_pLight.Position = tbVector3(0.0f, 2.0f, -3.0f);
    m_pLight.Range = 1000.0f;
    m_pLight.Attenuation0 = 0.0f;
    m_pLight.Attenuation1 = 0.25f;
    m_pLight.Attenuation2 = 0.0f;

    D3D->SetLight(0, &m_pLight);
    D3D->LightEnable(0, TRUE);

    xMaterial.Diffuse = tbColor(0.75f,0.75f,0.75f);
    xMaterial.Ambient = tbColor(0.25f,0.25f,0.25f);
    xMaterial.Emissive = tbColor(0.0f,0.0f,0.0f);
    xMaterial.Specular = tbColor(0.25f,0.25f,0.25f);
    xMaterial.Power = 5.0f;
    D3D->SetMaterial(&xMaterial);

    m_vLevelModel.Render();

    CPin::Instance().Render(fTime);

    D3D->EndScene();

    return TB_OK;
}

//Pin.h

#ifndef _PIN_INC_
#define _PIN_INC_

class CPin{
public:
    CPin();
    ~CPin();

    static CPin& Instance();

    tbResult Init();
    tbResult Load();
    tbResult Unload();
    tbResult Exit();
    int GetNextFreePlace();
    tbResult AddPin(int Place, int Zeile, int Spalte);
    tbResult SetColor(int Place, BOOL Color);
    tbResult SetRotation(int Place, BOOL Rotate);
    tbResult SetPosition(int Place, int Zeile, int Spalte,BOOL Sofort);
    tbResult Move(float fTime);
    tbResult Render(float fTime);

    //Ist Initalisiert?
    BOOL m_bInitialized;

    //Positionen der Pins
    tbVector3 m_vPosition[35];

    //Matrizen für die Pin-Modelle
    tbMatrix m_vPin1Matrix[35];
    tbMatrix m_vPin2Matrix[35];

    //Weerden die Position von den Pins gewechselt?
    BOOL m_bPosChange[35];
    float m_fTimeSinceStart[35];
    tbVector3 m_vEndPos[35];
    tbVector2 m_vWay[35];

    //Erxisitieren die Pins
    BOOL m_bExist[35];

    //Rotieren die Pins gerade?
    BOOL m_bRotate[35];

    //Wie lange rotieren sie schon?
    float m_fRotationTime[35];

    //Farbe - FALSE = SCHWARZ ; TRUE = WEIS
    BOOL m_bColor[35];

    //Pin Modelle
    tbModel m_vPinModelWhite1;
    tbModel m_vPinModelWhite2;
    tbModel m_vPinModelBlack1;
    tbModel m_vPinModelBlack2;
};

#endif

//Pin.cpp

#include "VierGewinnt.h"

CPin& CPin::Instance(){
    static CPin TheOneAndOnly;
    return TheOneAndOnly;
}

CPin::CPin(){}

CPin::~CPin(){
    if(m_bInitialized){
        CPin::Instance().Exit();
    }
}

tbResult CPin::Init(){
    TB_INFO("CPin wird initalisiert!");

    //Modelle laden
    if(Load()){
        return TB_ERROR;
    }

    for(int i=0;i<=34;i++){
        m_vPosition[i] = tbVector3(0.0f, 0.0f, 0.0f);
        m_vPin1Matrix[i] = tbMatrixTranslation(tbVector3(0.0f, 0.0f, 0.0f));
        m_vPin2Matrix[i] = tbMatrixTranslation(tbVector3(0.0f, 0.0f, 0.0f));
        m_bPosChange[i] = FALSE;
        m_fTimeSinceStart[i] = 0.0f;
        m_vEndPos[i] = tbVector3(0.0f, 0.0f, 0.0f);
        m_vWay[i] = tbVector2(0.0f, 0.0f);
        m_bExist[i] = FALSE;
        m_bRotate[i] = FALSE;
        m_fRotationTime[i] = 0.0f;
    }

    //Ist Initalisiert?
    BOOL m_bInitialized = TRUE;

    TB_INFO("CPin initalisiert!");

    return TB_OK;
}

tbResult CPin::Load(){
    //Modelle laden
    if(m_vPinModelWhite1.Init("PinWhite1.tbm")){
        //Fehler!
        TB_ERROR("Das weiße Pinmodel 1 konnte nicht geladen werden!", 
TB_ERROR);
        return TB_ERROR;
    }
    if(m_vPinModelWhite2.Init("PinWhite2.tbm")){
        //Fehler!
        TB_ERROR("Das weiße Pinmodel 2 konnte nicht geladen werden!", 
TB_ERROR);
        return TB_ERROR;
    }
    if(m_vPinModelBlack1.Init("PinBlack1.tbm")){
        //Fehler!
        TB_ERROR("Das schwarze Pinmodel 1 konnte nicht geladen werden!", 
TB_ERROR);
        return TB_ERROR;
    }
    if(m_vPinModelBlack2.Init("PinBlack2.tbm")){
        //Fehler!
        TB_ERROR("Das schwarze Pinmodel 2 konnte nicht geladen werden!", 
TB_ERROR);
        return TB_ERROR;
    }

    return TB_OK;
}

tbResult CPin::Unload(){
    //Pin Modelle entladen
    if(m_vPinModelWhite1.Exit()){
        TB_ERROR("Das weiße Pinmodel 1 konnte nicht entladen werden!", 
TB_ERROR);
    }
    if(m_vPinModelWhite2.Exit()){
        TB_ERROR("Das weiße Pinmodel 1 konnte nicht entladen werden!", 
TB_ERROR);
    }
    if(m_vPinModelBlack1.Exit()){
        TB_ERROR("Das schwarze Pinmodel 1 konnte nicht entladen werden!", 
TB_ERROR);
    }
    if(m_vPinModelBlack2.Exit()){
        TB_ERROR("Das schwarze Pinmodel 1 konnte nicht entladen werden!", 
TB_ERROR);
    }

    return TB_OK;
}

tbResult CPin::Exit(){
    TB_INFO("CPin wird heruntergefahren!");

    //Alles entladen
    if(Unload()){
        return TB_ERROR;
    }

    //CPin heruntergefahren
    m_bInitialized = FALSE;

    TB_INFO("CPin ist heruntergefahren!");

    return TB_OK;
}

int CPin::GetNextFreePlace(){
    for(int i=0;i<=34;i++){
        if(m_bExist[i] == FALSE){
            return i;
        }
    }
    return TB_ERROR;
}

tbResult CPin::AddPin(int Place, int Zeile, int Spalte){
    //Position ist nicht ausserhalb des Feldes!
    if(Zeile>5||Spalte>6){
        return TB_ERROR;
    }

    //Position 0/0
    float x = -1.5;
    float y = 3.25;
    float z = 0.0f;

    //Übergebene Position hinzuberechenen
    x+=(float)(Zeile*0.5);
    y+=(float)(Spalte*0.5);

    m_vPosition[Place] = tbVector3(x, y, z);
    m_vPin1Matrix[Place] = tbMatrixTranslation(tbVector3(0.0f, 0.0f, 0.0f));
    m_vPin2Matrix[Place] = tbMatrixTranslation(tbVector3(0.0f, 0.0f, 0.0f));
    m_bPosChange[Place] = FALSE;
    m_fTimeSinceStart[Place] = 0.0f;
    m_vEndPos[Place] = tbVector3(0.0f, 0.0f, 0.0f);
    m_vWay[Place] = tbVector2(0.0f, 0.0f);
    m_bExist[Place] = TRUE;
    m_bRotate[Place] = FALSE;
    m_fRotationTime[Place] = 0.0f;
    return TB_OK;
}

tbResult CPin::SetColor(int Place, BOOL Color){
    //Farbe wird geändert
    m_bColor[Place] = Color;
    return TB_OK;
}

tbResult CPin::SetRotation(int Place, BOOL Rotate){
    if(m_bRotate[Place] == Rotate){
        //Es brauchen keine Änderungen vorgenommen werden!
        return TB_OK;
    }

    //Zeit der Rotation wird zurückgesetzt
    m_fRotationTime[Place] = 0.0f;

    //Neue Rotation setzen
    m_bRotate[Place] = Rotate;
    return TB_OK;
}

tbResult CPin::SetPosition(int Place, int Zeile, int Spalte,BOOL Sofort){
    //Position ist nicht ausserhalb des Feldes!
    if(Zeile>5||Spalte>6){
        return TB_ERROR;
    }

    //Position 0/0
    float x = -1.5;
    float y = 3.25;
    float z = 0.0f;

    //Übergebene Position hinzuberechenen
    x+=(float)(Zeile*0.5);
    y+=(float)(Spalte*0.5);

    //Soll es einen Positionsübergang geben?
    if(Sofort==FALSE){
        //Position setzen
        m_vEndPos[Place] = tbVector3(x,y,z);

        //In der Move Funktion muss der Positionsübergang berechnet werden!
        m_bPosChange[Place] = TRUE;

        //Zeit Variable zurücksetzen
        m_fTimeSinceStart[Place] = 0.0f;

        //Weg berechnen
        m_vWay[Place].x = m_vEndPos[Place].x-m_vPosition[Place].x;
        m_vWay[Place].y = m_vEndPos[Place].y-m_vPosition[Place].y;
    }
    else{
        //Position setzen
        m_vPosition[Place] = tbVector3(x,y,z);

        //Die Position wurde sofort geändert
        //Es muss kein Übergang berechnet werden
        m_bPosChange[Place] = FALSE;
    }

    return TB_OK;
}

tbResult CPin::Move(float fTime){
    //Alle Pins durchgehen
    for(int i=0;i<=34;i++){
        //Findet gerade ein Positionsübergang statt?
        if(m_bPosChange[i] == TRUE){
            m_fTimeSinceStart[i]+=fTime;
            if(m_fTimeSinceStart[i] > 1.0f){
                m_bPosChange[i] = FALSE;
                m_vPosition[i] = m_vEndPos[i];
            }
            else{
                m_vPosition[i].x += (m_vWay[i].x * m_fTimeSinceStart[i]);
                m_vPosition[i].y += (m_vWay[i].y * m_fTimeSinceStart[i]);
            }
        }
        if(m_bRotate[i] == TRUE){
            //Matrizen für die Pinbewegung berechnen
            m_vPin1Matrix[i] = tbMatrixRotationX(90.0f * m_fRotationTime[i]);
            m_vPin2Matrix[i] = tbMatrixRotationY(30.0f * m_fRotationTime[i]);
        }
        else{
            //Matrizen für die Pinbewegung berechnen
            m_vPin1Matrix[i] = tbMatrixRotationX(0);
            m_vPin2Matrix[i] = tbMatrixRotationY(0);
        }
    }

    return TB_OK;
}

tbResult CPin::Render(float fTime){
    //Direct3D
    tbDirect3D &D3D = tbDirect3D::Instance();

    //Variablen
    tbMatrix mOldWorld;
    tbMatrix mWorld;

    //Alte Weltmatrix speichern
    mOldWorld = D3D.GetTransform(D3DTS_WORLD);

    for(int i=0;i<=34;i++){
        //Neue Weltmatrix einsetzen
        mWorld = tbMatrixTranslation(m_vPosition[i]) * m_vPin1Matrix[i];
        D3D.SetTransform(D3DTS_WORLD, mWorld);

        //Pin zeichnen
        if(m_bColor[i] == TRUE){
            m_vPinModelWhite1.Render();
        }
        else{
            m_vPinModelBlack1.Render();
        }

        //Neue Weltmatrix einsetzen
        mWorld = tbMatrixTranslation(m_vPosition[i]) * m_vPin2Matrix[i];
        D3D.SetTransform(D3DTS_WORLD, mWorld);

        //Pin zeichnen
        if(m_bColor[i] == TRUE){
            m_vPinModelWhite2.Render();
        }
        else{
            m_vPinModelBlack2.Render();
        }
    }

    //Alte Weltmatrix einsetzen
    D3D.SetTransform(D3DTS_WORLD, mOldWorld);
    return TB_OK;
}

Außerdem ist noch zu beachten, dass das Modell, das ich hochgeladen habe keine materialeinstellungen im Effekt enthält!

PS: Ich glaube ich lag mit meiner Schätzung von 300 Zeilen Falsch!!!

»Harry222« hat folgende Datei angehängt:

Model.tbm.zip (12,57 kB - 47 mal heruntergeladen - zuletzt: 21.05.2024, 14:38)

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »Harry222« (21.07.2010, 14:14)

Zum Seitenanfang

CBenni::O

1x Contest-Sieger

Beiträge: 1 145

Wohnort: Stuttgart

21.07.2010, 14:05

Warum rotiert deine Kamera?

Und Clear wird immer noch nicht aufgerufen...

Beachte BITTE mal unsere Vorschläge!

mfg CBenni::O

Ein Mitglied der VEGeiCoUndGraSonMaWiGeS Bewegung.
42!
Aufräumen kann jeder, nur das Genie überblickt das Chaos!
Metal will never die!
1. Sppro Gamecontest - mein Beitrag

Zum Seitenanfang

Alter Hase

Beruf: Student

21.07.2010, 14:13

Ich muss hier sagen, dass Clear aufgerufen WIRD! Ich habe das in der Kopie, die ich gestern vom Quellcode gemacht habe und jetzt gerade wider benutzt habe nur noch nicht geändert, was mir ehrlich leid tut! Aber ich ACHTE schon auf eure Tipps und habe den Code jetzt nochmal verbessert!
Die Kamera routiert übrigens, weil ich wollte, dass man im Intro das Levelmodell, mit ein paar reingeworfenen Pins sieht und die Kamera sich um die ganze Szenerie drehen soll! Ich glaube übrigens, dass da das Flimmern von den Pins herkommt. Ich MUSS da irgendetwas falsch gemacht haben!

Zum Seitenanfang

Supermoderator

21.07.2010, 14:44

Kann die Modelldatei momentan nicht testen.
Vielleicht liegts auch "nur" an der?
Interessieren würde mich noch die Initialisierung des Device, Erstellung des Fensters und die komplette Clear-Methode (Codezeile).

Tipp:
Etwas sparsamer mit Ausrufezeichen umgehen :!:

fka tm

Zum Seitenanfang

Alter Hase

Beruf: Student

21.07.2010, 15:00

Zuerst einmal ist hier die Codezeile, in der das Fenster erstellt wird:

C-/C++-Quelltext

// Direct3D initialisieren
if(tbDirect3D::Instance().Init(&m_Config, "Vier gewinnt", NULL, LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1)))){
    // Fehler!
       TB_ERROR("Fehler beim Initialisieren von Direct3D!", TB_ERROR);
}

Ich initalisiere einfach tbDirect3D. Das Fenster wird ja in dieser Funktion erstellt.

Die Clear-Funktion ist übrigens zwischen dem ganzen Quelltext, den ich oben eingetragen habe, aber ich führe sie trotzdem nochmal auf:

	C-/C++-Quelltext
1	D3D->Clear(0, NULL, D3DCLEAR_TARGET \| D3DCLEAR_ZBUFFER, tbColor(1.0f), 1.0f, 0);

Mfg Harry222!

Zum Seitenanfang

Supermoderator

21.07.2010, 15:15

Würde das Modell noch mal neu erstellen bzw. ins TBM-Format konvertieren.

Kannst du mal die 3ds-Datei hochladen?

fka tm

Zum Seitenanfang

Alter Hase