spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

#include "mfc/afxres.h"//das hier hingeschrieben:#define IDC_STATIC -1#include <windows.h>//Ausßerdem statt das:2 TEXTINCLUDE BEGIN    "#include ""afxres.h""\r\n"    "\0"END//das hier:2 TEXTINCLUDE BEGIN    "#include ""winres.h""\r\n"    "\0"END

Quellcode

CVTRES : fatal error CVT1100: duplicate resource.  type:DIALOG, name:901, language:0x04071>LINK : fatal error LNK1123: failure during conversion to COFF: file invalid or corrupt

C-/C++-Quelltext

//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by Texturen.rc
//
#define IDI_ICON1                   101

// Next default values for new objects
// 
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE    102
#define _APS_NEXT_COMMAND_VALUE     40001
#define _APS_NEXT_CONTROL_VALUE     1001
#define _APS_NEXT_SYMED_VALUE       101
#endif
#endif

C-/C++-Quelltext

// Kapitel 2
// Beispielprogramm 04
// ===================
// Dieses Programm zeigt ein sich bewegendes Feld von texturierten
// Dreiecken. Dabei werden die Unterschiede der Texturfilter
// eindrucksvoll demonstriert.

#include <Windows.h>
#include <TriBase.h>
#include "InitWindow.h"
#include "Direct3DEnum.h"
#include "InitDirect3D.h"
#include "Resource.h"

// ******************************************************************
// Struktur für einen Vertex: Position, Farbe und Texturkoordinaten
struct SVertex
{
    tbVector3           vPosition;  // Position des Vertex
    DWORD               dwColor;    // Farbe des Vertex
    tbVector2           vTexture;   // Texturkoordinaten
    static const DWORD  dwFVF;      // Vertexformat
};

const DWORD SVertex::dwFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1;

// ******************************************************************
// Struktur für ein Dreieck
struct STriangle
{
    tbVector3   vPosition;      // Position
    tbVector3   vVelocity;      // Bewegung (Richtung und Geschwindigkeit)
    tbVector3   vRotation;      // Rotationszustand
    tbVector3   vRotVelocity;   // Rotationsbewegung
    float       fSize;          // Größe
    SVertex     aVertex[3];     // Die drei Vertizes
};

// ******************************************************************
// Globale Variablen
const int           g_iNumTriangles = 1024;         // Anzahl der Dreiecke
float               g_fTime = 0.0f;                 // Zeitzähler
SDirect3DParameters g_Direct3DParameters;           // Direct3D-Parameter
STriangle           g_aTriangle[g_iNumTriangles];   // Die Dreiecke
PDIRECT3DTEXTURE9   g_pTexture = NULL;              // Die Textur

// ******************************************************************
// Render-Funktion
tbResult Render(float fNumSecsPassed)
{
    HRESULT     hResult;
    tbMatrix    mScaling;       // Skalierungsmatrix
    tbMatrix    mRotationX;     // Rotationsmatrix für die x-Achse
    tbMatrix    mRotationY;     // Rotationsmatrix für die y-Achse
    tbMatrix    mRotationZ;     // Rotationsmatrix für die z-Achse
    tbMatrix    mTranslation;   // Translationsmatrix
    tbMatrix    mWorld;         // Vereinende Weltmatrix


    // Den Bildpuffer und den Z-Buffer leeren
    if(FAILED(hResult = g_pD3DDevice->Clear(0,
                                            NULL,
                                            D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                                            D3DCOLOR_XRGB(0, 0, 63),
                                            1.0f,
                                            0)))
    {
        // Fehler beim Leeren!
        TB_ERROR_DIRECTX("g_pD3DDevice->Clear", hResult, TB_STOP);
    }

    // Szene beginnen
    g_pD3DDevice->BeginScene();

    // Abhängig von der Zeit die Texturfilter setzen.
    // Alle drei Sekunden werden diese geändert.
    if((int)(g_fTime / 3.0f) % 3 == 0)
    {
        // Bilineare Filter mit linearem MIP-Mapping
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
        SetWindowText(g_hWindow, "Beispielprogramm Nr. 4: Texturen (MIN: Linear, MAG: Linear, MIP: Linear)");
    }
    else if((int)(g_fTime / 3.0f) % 3 == 1)
    {
        // Keine Filter ("PlayStation-Effekt"), auch kein MIP-Mapping
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
        SetWindowText(g_hWindow, "Beispielprogramm Nr. 4: Texturen (MIN: Point, MAG: Point, MIP: None)");
    }
    else
    {
        // Maximaler anisotropischer Filter ohne MIP-Mapping
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAXANISOTROPY,
                                    g_Direct3DParameters.DeviceCaps.MaxAnisotropy);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
        g_pD3DDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
        SetWindowText(g_hWindow, "Beispielprogramm Nr. 4: Texturen (MIN: Anisotropic, MAG: Linear, MIP: None)");
    }

    // Jedes einzelne Dreieck zeichnen
    for(int iTriangle = 0; iTriangle < g_iNumTriangles; iTriangle++)
    {
        // Skalierungsmatrix anhand der Größe des Dreiecks erstellen
        mScaling = tbMatrixScaling(tbVector3(g_aTriangle[iTriangle].fSize));

        // Rotationsmatrizen für das Dreieck erzeugen
        mRotationX = tbMatrixRotationX(g_aTriangle[iTriangle].vRotation.x);
        mRotationY = tbMatrixRotationY(g_aTriangle[iTriangle].vRotation.y);
        mRotationZ = tbMatrixRotationZ(g_aTriangle[iTriangle].vRotation.z);

        // Translationsmatrix
        mTranslation = tbMatrixTranslation(g_aTriangle[iTriangle].vPosition);
        
        // Alle Matrizen kombinieren und als Weltmatrix einsetzen
        mWorld = mScaling * mRotationX * mRotationY * mRotationZ * mTranslation;
        g_pD3DDevice->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&mWorld));

        if(FAILED(hResult = g_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST,               // Dreiecksliste
                                                        1,                              // 1 Dreieck
                                                        g_aTriangle[iTriangle].aVertex, // Vertexdaten
                                                        sizeof(SVertex))))              // Vertexgröße
        {
            // Fehler beim Zeichnen!
            TB_ERROR_DIRECTX("g_pD3DDevice->DrawPrimitiveUP", hResult, TB_STOP);
        }
    }

    // Szene beenden
    g_pD3DDevice->EndScene();

    // Der große Moment: den Bildpuffer sichtbar machen
    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);

    return TB_OK;
}

// ******************************************************************
// Move-Funktion
tbResult Move(float fNumSecsPassed)
{
    float fDistance;

    // Zeitzähler erhöhen
    g_fTime += fNumSecsPassed;

    // Wenn der Benutzer die Leertaste drückt, wird das Programm angehalten.
    // So sind die Wirkungen der verschiedenen Filter besser zu erkennen.
    if(GetAsyncKeyState(VK_SPACE)) fNumSecsPassed = 0.0f;

    // Jedes Dreieck bewegen
    for(int iTriangle = 0; iTriangle < g_iNumTriangles; iTriangle++)
    {
        // Position und Rotation aktualisieren
        g_aTriangle[iTriangle].vPosition += g_aTriangle[iTriangle].vVelocity * fNumSecsPassed;
        g_aTriangle[iTriangle].vRotation += g_aTriangle[iTriangle].vRotVelocity * fNumSecsPassed;

        // Distanz des Dreiecks zum Beobachter (zum Nullpunkt) berechnen
        fDistance = tbVector3Length(g_aTriangle[iTriangle].vPosition);

        // Wenn die Distanz größer als 100 ist, soll das Dreieck umkehren.
        if(fDistance > 100.0f) g_aTriangle[iTriangle].vVelocity *= -1.0f;
    }

    return TB_OK;
}

// ******************************************************************
// Herunterfahren der Szene
tbResult ExitScene()
{
    // Textur deaktivieren und löschen
    g_pD3DDevice->SetTexture(0, NULL);
    TB_SAFE_RELEASE(g_pTexture);

    return TB_OK;
}

// ******************************************************************
// Herunterfahren der Anwendung
tbResult ExitApplication()
{
    // Szene herunterfahren
    ExitScene();

    // Direct3D und Fenster herunterfahren
    ExitDirect3D();
    ExitWindow();

    // Engine herunterfahren
    tbExit();

    return TB_OK;
}

// ******************************************************************
// Initialisieren der Szene
tbResult InitScene()
{
    HRESULT     hResult;
    tbMatrix    mProjection;
    float       fAspect;
    tbColor     VertexColor;


    // Vertexformat setzen - Positions-, Farb- und Texturkoordinatenangabe
    if(FAILED(hResult = g_pD3DDevice->SetFVF(SVertex::dwFVF)))
    {
        // Fehler beim Setzen des Vertexformats!
        TB_ERROR_DIRECTX("g_pD3DDevice->SetFVF", hResult, TB_ERROR);
    }

    // Beleuchtung und Culling ausschalten, Dithering aktivieren
    g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
    g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    g_pD3DDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);

    // Das Bildseitenverhältnis berechnen
    fAspect =   (float)(g_Direct3DParameters.VideoMode.Width)
            / (float)(g_Direct3DParameters.VideoMode.Height);

    // Die Projektionsmatrix erzeugen
    mProjection = tbMatrixProjection(TB_DEG_TO_RAD(90.0f),  // Sichtfeld: 90°
                                    fAspect,                // Bildseitenverhältnis
                                    0.1f,                   // Nahe Clipping-Ebene
                                    100.0f);                // Ferne Clipping-Ebene

    // Projektionsmatrix einsetzen
    g_pD3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)(&mProjection));

    // Initialisieren der Dreiecke
    for(int iTriangle = 0; iTriangle < g_iNumTriangles; iTriangle++)
    {
        // Alle Dreiecke starten am Punkt (0, 0, 50).
        g_aTriangle[iTriangle].vPosition = tbVector3(0.0f, 0.0f, 50.0f);

        // Die Bewegung ist zufällig.
        g_aTriangle[iTriangle].vVelocity = tbVector3Random() * tbFloatRandom(0.1f, 5.0f);

        // Rotation zurücksetzen
        g_aTriangle[iTriangle].vRotation = tbVector3(0.0f, 0.0f, 0.0f);

        // Rotationsgeschwindigkeit ist zufällig auf allen drei Achsen
        g_aTriangle[iTriangle].vRotVelocity.x = tbFloatRandom(-1.0f, 1.0f);
        g_aTriangle[iTriangle].vRotVelocity.y = tbFloatRandom(-1.0f, 1.0f);
        g_aTriangle[iTriangle].vRotVelocity.z = tbFloatRandom(-1.0f, 1.0f);

        // Größe zufällig zwischen 1 und 5 festlegen
        g_aTriangle[iTriangle].fSize = tbFloatRandom(1.0f, 5.0f);

        // Nun die einzelnen Vertizes generieren.
        for(int iVertex = 0; iVertex < 3; iVertex++)
        {
            // Position
            g_aTriangle[iTriangle].aVertex[iVertex].vPosition = tbVector3Random();

            // Farbe
            VertexColor.r = tbFloatRandom(0.0f, 1.0f);
            VertexColor.g = tbFloatRandom(0.0f, 1.0f);
            VertexColor.b = tbFloatRandom(0.0f, 1.0f);
            g_aTriangle[iTriangle].aVertex[iVertex].dwColor = (DWORD)(VertexColor);

            // Texturkoordinaten zufällig zwischen -1 und 2 erzeugen
            g_aTriangle[iTriangle].aVertex[iVertex].vTexture.u = tbFloatRandom(-1.0f, 2.0f);
            g_aTriangle[iTriangle].aVertex[iVertex].vTexture.v = tbFloatRandom(-1.0f, 2.0f);
        }
    }

    // Die Textur laden
    if(FAILED(hResult = D3DXCreateTextureFromFileEx(g_pD3DDevice,       // Device
                                                    "Texture.bmp",      // Dateiname
                                                    D3DX_DEFAULT,       // Breite
                                                    D3DX_DEFAULT,       // Höhe
                                                    D3DX_DEFAULT,       // MIP-Maps
                                                    0,                  // Verwendungszweck
                                                    D3DFMT_UNKNOWN,     // Format
                                                    D3DPOOL_MANAGED,    // Speicherklasse
                                                    D3DX_FILTER_NONE,   // Filter
                                                    D3DX_DEFAULT,       // MIP-Map-Filter
                                                    0,                  // Color-Key
                                                    NULL,               // Unwichtig
                                                    NULL,               // Unwichtig
                                                    &g_pTexture)))      // Die Textur
    {
        // Fehler!
        TB_ERROR_DIRECTX("D3DXCreateTextureFromFileEx", hResult, TB_ERROR);
    }

    // Und nun die Textur einsetzen
    g_pD3DDevice->SetTexture(0, g_pTexture);

    return TB_OK;
}

// ******************************************************************
// Initialisierungsfunktion
tbResult InitApplication()
{
    tbResult Result;

    // TriBase-Engine initialisieren
    tbInit();

    // Direct3D-Optionen abfragen (vom Benutzer gewählt)
    Result = GetDirect3DParameters(&g_Direct3DParameters);
    if(Result == TB_ERROR)
    {
        // Es trat ein Fehler auf!
        MessageBox(NULL, "Fehler beim Abzählen!", "Fehler",
                MB_OK | MB_ICONEXCLAMATION);
        return TB_ERROR;
    }
    else if(Result == TB_CANCELED)
    {
        // Der Dialog wurde abgebrochen!
        return TB_CANCELED;
    }

    // Fenster initialisieren. Die Größe hängt vom gewählten
    // Videomodus ab, der in der Parameterstruktur gespeichert ist.
    if(InitWindow(g_Direct3DParameters.VideoMode.Width,
                g_Direct3DParameters.VideoMode.Height,
                  "Beispielprogramm Nr. 4: Texturen",
                  LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1))))
    {
        // Fehler beim Erstellen des Fensters!
        MessageBox(NULL, "Fehler beim Erstellen des Fensters!",
                "Fehler", MB_OK | MB_ICONEXCLAMATION);
        return TB_ERROR;
    }

    // Direct3D mit den abgefragten Einstellungen initialisieren
    if(InitDirect3D(&g_Direct3DParameters,
                    g_hWindow))
    {
        // Fehler!
        MessageBox(g_hWindow, "Fehler beim Initialisieren von Direct3D!",
                "Fehler", MB_OK | MB_ICONEXCLAMATION);
        ExitApplication();
        return TB_ERROR;
    }

    // Szene initialisieren
    if(InitScene())
    {
        // Fehler!
        MessageBox(g_hWindow, "Fehler beim Initialisieren der Szene!",
                "Fehler", MB_OK | MB_ICONINFORMATION);
        ExitApplication();
        return TB_ERROR;
    }

    // Alles OK!
    return TB_OK;
}

// ******************************************************************
// Windows-Hauptfunktion
int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   char* pcCmdLine,
                   int iShowCmd)
{
    tbResult Result;

    // Initialisierung
    Result = InitApplication();
    if(Result == TB_CANCELED) return 0;
    else if(Result)
    {
        MessageBox(NULL, "Fehler beim Initialisieren der Anwendung!",
                "Fehler", MB_OK | MB_ICONEXCLAMATION);
        return 1;
    }

    // Nachrichtenschleife
    tbDoMessageLoop(Render, Move);

    // Herunterfahren
    ExitApplication();

    return 0;
}

// ******************************************************************

C-/C++-Quelltext

#include "Allgemeines.rc"

// Microsoft Visual C++ generated resource script.
//
#include "resource.h"

#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 2 resource.
//
//#include "mfc/afxres.h"
#define IDC_STATIC -1
#include <windows.h>

/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS

/////////////////////////////////////////////////////////////////////////////
// Deutsch (Deutschland) resources

#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_DEU)
#ifdef _WIN32
LANGUAGE LANG_GERMAN, SUBLANG_GERMAN
#pragma code_page(1252)
#endif //_WIN32

#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//

1 TEXTINCLUDE 
BEGIN
"resource.h\0"
END

2 TEXTINCLUDE 
BEGIN
"#include ""winres.h""\r\n"
"\0"
END

3 TEXTINCLUDE 
BEGIN
"\r\n"
"\0"
END

#endif// APSTUDIO_INVOKED


/////////////////////////////////////////////////////////////////////////////
//
// Icon
//

// Icon with lowest ID value placed first to ensure application icon
// remains consistent on all systems.
IDI_ICON1           ICON                "Icon1.ico"
#endif// Deutsch (Deutschland) resources
/////////////////////////////////////////////////////////////////////////////



#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//


/////////////////////////////////////////////////////////////////////////////
#endif// not APSTUDIO_INVOKED