Spotlichtproblem

Alter Hase

06.03.2007, 20:51

Spotlichtproblem

sry,dass ich schon wieder nerve, aber das das dürfte das letzte jetzt sein,was mich beschäftigt :=

also thema spotlich:
ich hab ein spotlicht in die szene mit den vielen würfeln gesetzt (sollte eh fast jeder kennen,der das buch gelesen hat

) gesetzt und lass es auf der z achse rotieren, aber irgendwie merk ich von dem licht nix oO

woran könnte es liegen , wie immer komme ich nicht dahiner sonst würd ich hier ned fragen :=)

mfg
Simon

C-/C++-Quelltext

// VIbuffer mit Nebel und Licht.cpp

// author : Simon Klausner

// version : 0.1

// purpose : use vertex and index buffer for DrawPrimitive

//                   integrate fog and light


#define D3D_DEBUG_INFO

#include <windows.h>
#include <TriBase.h>
#include <d3dx9.h>
#include <I:\\Spiele Programmierung\\Beispiele\\Allgemeines\\InitWindow.h>
#include <I:\\Spiele Programmierung\\Beispiele\\Allgemeines\\Direct3DEnum.h>
#include <I:\\Spiele Programmierung\\Beispiele\\Allgemeines\\InitDirect3D.h>
#include <I:\\Spiele Programmierung\\Beispiele\\Allgemeines\\Allgemeines.h>



// Globals

struct SVertex                                  // structure for Vertex

{
    tbVector3   vPosition;                  // Position

    tbVector3 vNormal;                      // Normalvector

    tbVector2   vTexture;                       // Texturecoordinates

    static const DWORD  dwFVF;      // Vertexformat

};
const DWORD SVertex::dwFVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1;
const int   g_iNumCubes = 2048;                                         // Number of Cubes

float   g_fTime = 0.0f;                                                         // Timecounter

SDirect3DParameters g_Direct3DParameters;                   // D3D Parameters

PDIRECT3DTEXTURE9   g_pTexture = NULL;                          // Texture

PDIRECT3DVERTEXBUFFER9 g_pVertexBuffer = NULL;      // Vertex-Buffer

PDIRECT3DINDEXBUFFER9 g_pIndexBuffer = NULL;            // Index-Buffer

tbVector3   g_vCameraPosition;                                          // Position of Cam

float   g_fCameraAngle = 0.0f;                                          // Angle of Cam

float   g_fFOV = TB_DEG_TO_RAD(90.0f);                          // Field of View

tbColor g_FogColor = (0.0f, 0.0f, 0.3f);                    // TriBase Fogcolor

DWORD g_dwFogColor = (DWORD)(g_FogColor);                   // Fogcolor

float g_fColorchange = 0.3f;
D3DLIGHT9 Light;                                                                    // SpotLight




// function : Render

tbResult Render(float fNumSecsPassed)
{
    // Variables

    HRESULT hResult;
    float   fAspect;
    tbMatrix mCamera;
    tbMatrix mProjection;


    // Clear Picture and Z-Buffer

    if(FAILED(hResult = g_pD3DDevice->Clear(0,
                                                                                    NULL,
                                                                                    D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                                                                                    g_dwFogColor,
                                                                          1.0f,
                                                                            0)))
    {
        // Error

        TB_ERROR_DIRECTX("g_pD3DDevice->Clear", hResult, TB_STOP);
    }

    // Begin Scene

    g_pD3DDevice->BeginScene();

    // Fog on

    g_pD3DDevice->SetRenderState(D3DRS_FOGENABLE, TRUE);
    // Vertexfog

    g_pD3DDevice->SetRenderState(D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
    g_pD3DDevice->SetRenderState(D3DRS_FOGTABLEMODE, D3DFOG_NONE);
    // Fogcolor

    g_pD3DDevice->SetRenderState(D3DRS_FOGCOLOR, g_dwFogColor);
    // Fogstart and end

    float fFogStart = 60.0f;
    g_pD3DDevice->SetRenderState(D3DRS_FOGSTART, *((DWORD*)(&fFogStart)));
    float fFogEnd = 200.0f;
    g_pD3DDevice->SetRenderState(D3DRS_FOGEND, *((DWORD*)(&fFogEnd)));
    // use real distance of vertex for fog calculating

    g_pD3DDevice->SetRenderState(D3DRS_RANGEFOGENABLE, TRUE);

    // Light on

    ZeroMemory(&Light, sizeof(D3DLIGHT9));
    Light.Type = D3DLIGHT_SPOT;
    Light.Diffuse = tbColor(1.0f, 1.0f, 1.0f);
    Light.Ambient = tbColor(1.0f, 1.0f, 1.0f);
    Light.Specular = tbColor(0.75f, 0.75f, 0.75f);
    Light.Position = tbVector3(0.0f, 0.0f, 0.0f);
    Light.Direction = tbVector3(sinf(g_fTime), 0.0f, cosf(g_fTime));
    Light.Range = 1000.0f;
    Light.Attenuation0 = 0.0f;
    Light.Attenuation1 = 0.03f;
    Light.Attenuation2 = 0.00f;
    Light.Theta = TB_DEG_TO_RAD(60);
    Light.Phi = TB_DEG_TO_RAD(150);
    Light.Falloff = 0.2f;
    // Activate Light

    g_pD3DDevice->SetLight(0, &Light);
    g_pD3DDevice->LightEnable(0, TRUE);
    // Gloabl Light

    g_pD3DDevice->SetRenderState(D3DRS_AMBIENT, tbColor(0.15f, 0.15f, 0.15f));

    // Set Material

    D3DMATERIAL9 Material;
    Material.Diffuse = tbColor(0.15f, 0.75f, 0.0f);
    Material.Ambient = tbColor(0.1f, 0.5f, 0.1f);
    Material.Specular = tbColor(0.0f, 0.0f, 0.8f);
    Material.Emissive = tbColor(0.0f, 0.0f, 0.0f);
    Material.Power = 10.0f;
    g_pD3DDevice->SetMaterial((&Material));

    // Create and Set Cameramatrix

    mCamera = tbMatrixCamera(g_vCameraPosition,
                                                     g_vCameraPosition + tbVector3(sinf(g_fCameraAngle),
                                                                                                                0.0f,
                                                                                                                cosf(g_fCameraAngle)),
                                                     tbVector3(0.0f, 1.0f, 0.0f));
    g_pD3DDevice->SetTransform(D3DTS_VIEW, (D3DMATRIX*)(&mCamera));

    // Picturepropotion

    fAspect = (float)(g_Direct3DParameters.VideoMode.Width)
              / (float)(g_Direct3DParameters.VideoMode.Height);

    // Create and Set Projectionmatrix

    mProjection = tbMatrixProjection(g_fFOV,
                                                                     fAspect,
                                                                     0.1f,
                                                                     250.0f);
    g_pD3DDevice->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)(&mProjection));

    // Draw all cubes

    // Set Vertex- and Indexbuffer for datasource

    g_pD3DDevice->SetStreamSource(0, g_pVertexBuffer, 0, sizeof(SVertex));
    g_pD3DDevice->SetIndices(g_pIndexBuffer);

    // Draw

    hResult = g_pD3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,
                                                                                             0,
                                                                                             0,
                                                                                             g_iNumCubes * 8,
                                                                                             0,
                                                                                             g_iNumCubes * 12);
    if(FAILED(hResult))
    {
        // Error

        TB_ERROR_DIRECTX("g_pD3DDevice->DrawIndexedPrimitive", hResult, TB_STOP);
    }

    // End Scene

    g_pD3DDevice->EndScene();

    // Present Scene

    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);

    return TB_OK;
}   // end function : Render




// function : Move

tbResult Move(float fNumSecsPassed)
{
    // Variables

    tbVector3 vCameraDirection;

    // Increase Timecounter

    g_fTime += fNumSecsPassed;
    g_FogColor = (0.0f, 0.0f, 0.3f+0.1f);


    if(GetAsyncKeyState(VK_LEFT)) 
        g_fCameraAngle -= TB_DEG_TO_RAD(70.0f) * fNumSecsPassed;
    if(GetAsyncKeyState(VK_RIGHT)) 
        g_fCameraAngle += TB_DEG_TO_RAD(70.0f) * fNumSecsPassed;
    vCameraDirection = tbVector3(sinf(g_fCameraAngle), 0.0f, cosf(g_fCameraAngle));

    if(GetAsyncKeyState(VK_UP)) 
        g_vCameraPosition += vCameraDirection * 20.0f * fNumSecsPassed;
    if(GetAsyncKeyState(VK_DOWN)) 
        g_vCameraPosition -= vCameraDirection * 20.0f * fNumSecsPassed;

    if(GetAsyncKeyState(VK_PRIOR)) 
        g_fFOV -= TB_DEG_TO_RAD(15.0f) * fNumSecsPassed;
    if(GetAsyncKeyState(VK_NEXT)) 
        g_fFOV += TB_DEG_TO_RAD(15.0f) * fNumSecsPassed;

    // Field of View != 180° %% 0°

    if(g_fFOV >= TB_DEG_TO_RAD(180.0f)) 
        g_fFOV = TB_DEG_TO_RAD(179.9f);
    else if(g_fFOV <= TB_DEG_TO_RAD(0.0f)) 
        g_fFOV = TB_DEG_TO_RAD(0.1f);

    return TB_OK;
}   // end function : Move




// function : Exit Scene

tbResult ExitScene()
{
    // Remove Texture

    g_pD3DDevice->SetTexture(0, NULL);
    TB_SAFE_RELEASE(g_pTexture);

    // Remove Vertex- and Indexbuffer

    g_pD3DDevice->SetStreamSource(0, NULL, 0, 0);
    g_pD3DDevice->SetIndices(NULL);
    TB_SAFE_RELEASE(g_pVertexBuffer);
    TB_SAFE_RELEASE(g_pIndexBuffer);

    return TB_OK;
}   // end function : Exit Scene




// function : Exit Application

tbResult ExitApplication()
{
    // Exit Scene

    ExitScene();

    // Exit D3D and close window

    ExitDirect3D();
    ExitWindow();

    // Exit Engine

    tbExit();

    return TB_OK;
}   // end function : Exit Application




// function : Init Scene

tbResult InitScene()
{
    // Variables

    HRESULT hResult;
    SVertex* pVertices;
    unsigned short* pusIndices;
    tbVector3 vCubePosition;
    int iStartVertex;
    int iStartIndex;


    // Set Vertexformat

    if(FAILED(hResult = g_pD3DDevice->SetFVF(SVertex::dwFVF)))
    {
        // Error

        TB_ERROR_DIRECTX("g_pD3DDevice->SetFVF", hResult, TB_ERROR);
    }

  // Lightning on, Culling off

    g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, TRUE);
    g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    // Dithering on

    g_pD3DDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);

    // linear Texturefilter with linear 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);

    // Load Texture

    if(FAILED(hResult = D3DXCreateTextureFromFileEx(g_pD3DDevice,
                                                                                                "Texture.bmp",
                                                                                                    D3DX_DEFAULT,
                                                                                                    D3DX_DEFAULT,
                                                                                                    D3DX_DEFAULT,
                                                                                                    0,
                                                                                                    D3DFMT_UNKNOWN,
                                                                                                    D3DPOOL_MANAGED,
                                                                                                    D3DX_FILTER_NONE,
                                                                                                    D3DX_DEFAULT,
                                                                                                    0,
                                                                                                    NULL,
                                                                                                    NULL,
                                                                                                    &g_pTexture)))
    {
        // Error

        TB_ERROR_DIRECTX("D3DXCreateTextureFromFileEx", hResult, TB_ERROR);
    }

    // Set Texture

    g_pD3DDevice->SetTexture(0, g_pTexture);


    // Create Vertexbuffer

    if(FAILED(hResult = g_pD3DDevice->CreateVertexBuffer(g_iNumCubes * 8 * sizeof(SVertex),
                                                                                                             0,
                                                                                                             SVertex::dwFVF,
                                                                                                             D3DPOOL_MANAGED,
                                                                                                             &g_pVertexBuffer,
                                                                                                             NULL)))
    {
        // Error

        TB_ERROR_DIRECTX("g_pD3DDevice->CreateVertexBuffer", hResult, TB_ERROR);
    }

    // Create Indexbuffer 16bit

    if(FAILED(hResult = g_pD3DDevice->CreateIndexBuffer(g_iNumCubes * 36 * 2,
                                                                                                            0,
                                                                                                            D3DFMT_INDEX16,
                                                                                                            D3DPOOL_MANAGED,
                                                                                                            &g_pIndexBuffer,
                                                                                                            NULL)))
    {
        // Error

        TB_ERROR_DIRECTX("g_pD3DDevice->CreateIndexBuffer", hResult, TB_ERROR);
    }

    // Lock Vertex and Indexbuffer

    g_pVertexBuffer->Lock(0, 0, (void**)(&pVertices), D3DLOCK_NOSYSLOCK);
    g_pIndexBuffer->Lock(0, 0, (void**)(&pusIndices), D3DLOCK_NOSYSLOCK);

    // Create Cubes

    for(int iCube = 0; iCube < g_iNumCubes; iCube++)
    {
        // Position = random

        vCubePosition = tbVector3Random() * tbFloatRandom(20.0f, 250.0f);

        // Set Startvertex and Startindex

        iStartVertex = iCube * 8;
        iStartIndex = iCube * 36;

        // Vertexposition

        pVertices[iStartVertex + 0].vPosition = vCubePosition + tbVector3(-1.0f,  1.0f, -1.0f);
        pVertices[iStartVertex + 1].vPosition = vCubePosition + tbVector3(-1.0f,  1.0f,  1.0f);
        pVertices[iStartVertex + 2].vPosition = vCubePosition + tbVector3( 1.0f,  1.0f,  1.0f);
        pVertices[iStartVertex + 3].vPosition = vCubePosition + tbVector3( 1.0f,  1.0f, -1.0f);
        pVertices[iStartVertex + 4].vPosition = vCubePosition + tbVector3(-1.0f, -1.0f, -1.0f);
        pVertices[iStartVertex + 5].vPosition = vCubePosition + tbVector3(-1.0f, -1.0f,  1.0f);
        pVertices[iStartVertex + 6].vPosition = vCubePosition + tbVector3( 1.0f, -1.0f,  1.0f);
        pVertices[iStartVertex + 7].vPosition = vCubePosition + tbVector3( 1.0f, -1.0f, -1.0f);

        // Normalvector

    pVertices[iCube*8].vNormal = tbVector3Normalize(                                    
        (tbVector3Cross(pVertices[iCube*8].vPosition, pVertices[(iCube*8)+2].vPosition)+ 
         tbVector3Cross(pVertices[iCube*8].vPosition, pVertices[(iCube*8)+2].vPosition)+ 
         tbVector3Cross(pVertices[iCube*8].vPosition, pVertices[(iCube*8)+5].vPosition)+ 
         tbVector3Cross(pVertices[iCube*8].vPosition, pVertices[(iCube*8)+5].vPosition)+ 
         tbVector3Cross(pVertices[iCube*8].vPosition, pVertices[(iCube*8)+7].vPosition)+ 
         tbVector3Cross(pVertices[iCube*8].vPosition, pVertices[(iCube*8)+7].vPosition))  / 6);

        for(int iVertex = iStartVertex; iVertex < iStartVertex + 8; iVertex++)
        {
            // // Texturecoordinates = random

            pVertices[iVertex].vTexture = tbVector2Random();
        }

        // Set Index

        int aiIndex[36] = {0, 3, 7,   0, 7, 4,  // Front

                                             2, 1, 5,   2, 5, 6,    // Back

                                             1, 0, 4,   1, 4, 5,    // Left

                                         3, 2, 6,   3, 6, 7,    // Right

                                         0, 1, 2,   0, 2, 3,    // Top

                                         6, 5, 4,   6, 4, 7};   // Bottom


        // Assign Index to Index Buffer

        for(int iIndex = 0; iIndex < 36; iIndex++)
        {
            pusIndices[iStartIndex + iIndex] = aiIndex[iIndex] + iStartVertex;
        }
    }

    // Unlock Vertex- and Indexbuffer

    g_pVertexBuffer->Unlock();
    g_pIndexBuffer->Unlock();

    return TB_OK;
}   // end function : Init Scene




// function : Init Application

tbResult InitApplication()
{
    // Variables

    tbResult Result;

    // Init Engine

    tbInit();

    // Get Direct3D Options

    Result = GetDirect3DParameters(&g_Direct3DParameters);
    if(Result == TB_ERROR)
    {
        // Error

        MessageBox(NULL, "Fehler beim Abzählen!", "Fehler",
                             MB_OK | MB_ICONEXCLAMATION);
        return TB_ERROR;
    }
    else if(Result == TB_CANCELED)
    {
        // Error

        return TB_CANCELED;
    }

    // Create Window

    if(InitWindow(g_Direct3DParameters.VideoMode.Width,
                                g_Direct3DParameters.VideoMode.Height,
                                "Vertex- und Index-Buffer",
                                LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1))))
    {
        // Error

        MessageBox(NULL, "Fehler beim Erstellen des Fensters!",
                            "Fehler", MB_OK | MB_ICONEXCLAMATION);
        return TB_ERROR;
    }

    // Initiate Direct3D

    if(InitDirect3D(&g_Direct3DParameters,
                    g_hWindow))
    {
        // Error

        MessageBox(g_hWindow, "Fehler beim Initialisieren von Direct3D!",
                             "Fehler", MB_OK | MB_ICONEXCLAMATION);
        ExitApplication();
        return TB_ERROR;
    }

    // Initiate Scene

    if(InitScene())
    {
        // Error

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

    return TB_OK;
}   // end function : Init Application




// function : main

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, char* pcCmdLine, int iShowCmd)
{
    // Variables

    tbResult Result;

    // Initiate Application

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

    // Messageloop

    tbDoMessageLoop(Render, Move);

    // Exit Application

    ExitApplication();

    return 0;
}   // end function : main

Zum Seitenanfang

Supermoderator

Wohnort: Graz

06.03.2007, 21:11

ich hab mir das jetzt nicht alles durchgelesen. ein screenshot wär hilfreich.
bei spotlights ist oft das problem, dass die auflösung der geometrie nicht gut genug ist und das ganze grauenhaft aussieht

du musst immer bedenken, dass die beleuchtung per vertex funktioniert!
wenn kein vertex vom spotlight getroffen wird, dann bleibts dunkel.
wenn du z.b. eine große ebene aus 2 dreiecken mit einem spotlight beleuchtest, dann wirds ziemlich finster sein...

außerdem leuchtet dein licht immer entlang oder entgegengesetzt der z achse (lediglich die länge des richtungsvektors ändert sich mit der zeit, richtung bleibt gleich! ich denke nicht, dass das absicht ist, denn das is ziemlich sinnlos

)

und außerdem seh ich nicht, dass du irgendwo normalvektoren setzt. ohne die geht aber gar nix

Zum Seitenanfang

Alter Hase

06.03.2007, 21:20

so hier das ganze im überblick, vom licht erkennt man irgendwie wenig bis gar nichts(ich find eher gar nichts

)

(Link)

und hier ein screen,wo man links untem am eck des würfels die beleuchtung sieht(blinkt periodisch auf und ab wegen der rotation des spots)

(Link)

irgendwie ist das ja aber sehr schwach... dunkelt der nebel das so arg ab? oder hab ich irgendwas falsch eingestellt dass das so mikrig ausfällt? bin jetzt selber nur durch zufall auf diesen beleuchteten würfel gekommen somit hat sich die frage ja erledigt obs funktioniert oder nicht

aber etwas stärker sollte das ja schon irgendwie sein

Zum Seitenanfang

Supermoderator

Wohnort: Graz

06.03.2007, 21:24

so in etwa hab ich mir das vorgestellt

ich hab oben noch was edtiert.

wie gesagt, das licht rotiert nicht (da fehlt der cos bei der x-koordinate) und es fehlen die normalvektoren (falls ich die nicht irgendwie übersehen hab

)

außerdem stell mal das ambient light etwas runter, dann sieht man evtl. den spot gleich besser...

Zum Seitenanfang

Alter Hase

06.03.2007, 21:29

hab rotation auf x-achse geändert, frag mich ned wieso ich die z-achse wollte

aber das mit den normalvektoren muss man noch setzen? achso dachte das würde alles automatisch von directx getan werden, wenn es weiß,dass der vertex nen normalvektor hat

danke hat wieder einmal geholfen =)

schönen abend noch

Zum Seitenanfang

Supermoderator

Wohnort: Graz

06.03.2007, 21:34

nein, das macht dx nicht von selber

geht's jetzt?

Zitat

hab rotation auf x-achse geändert, frag mich ned wieso ich die z-achse wollte

	Quellcode
1	Light.Direction = tbVector3(cosf(g_fTime), 0.0f, sinf(g_fTime));

hast du jetzt so gemacht!? wenn du den sin oder cos nur in einer koordinate hast, wird nicht wirklich viel rotieren

Zum Seitenanfang

Alter Hase

06.03.2007, 21:39

hm ich habs so

	C-/C++-Quelltext
1	Light.Direction = tbVector3(sinf(g_fTime), 0.0f, cosf(g_fTime));

aber wird sich gleich bleiben nur dass die rotation entgegengesetzt läuft?

aber jetzt bin ich grad dabei wie ich das einfach mit den normalvektoren mach

wird noch dauern

aber die rotation ist jetzt jedenfalls flüssiger. habs bei nem würfel nachgeprüft das dunkelt jetzt schön ab und hellt schön auf wie ein "leuchtturm" das halt so macht

edit: LOL etz scheints zu gehen das lag aber woanders

also erst mal ne frage funktioniert dieser "algorithmus" für die normalvektorbestimmung alles würfel?

C-/C++-Quelltext

// Normalvector

    pVertices[iCube*8].vNormal = tbVector3Normalize(                                    
        (tbVector3Cross(pVertices[iCube*8].vPosition, pVertices[(iCube*8)+2].vPosition)+ 
         tbVector3Cross(pVertices[iCube*8].vPosition, pVertices[(iCube*8)+2].vPosition)+ 
         tbVector3Cross(pVertices[iCube*8].vPosition, pVertices[(iCube*8)+5].vPosition)+ 
         tbVector3Cross(pVertices[iCube*8].vPosition, pVertices[(iCube*8)+5].vPosition)+ 
         tbVector3Cross(pVertices[iCube*8].vPosition, pVertices[(iCube*8)+7].vPosition)+ 
         tbVector3Cross(pVertices[iCube*8].vPosition, pVertices[(iCube*8)+7].vPosition))  / 6);

und zweitens lags daran,dass das spotlight so schwach ist

	C-/C++-Quelltext
1 2 3	Light.Attenuation0 = 0.0f; Light.Attenuation1 = 0.03f; Light.Attenuation2 = 0.00f;

ich hab attenuation2 mit 0.03f gehabt und ned attenuation1, weil ich mich im buch verlesen habe ich alter legasteniker *fg*

Zum Seitenanfang

Supermoderator

Wohnort: Graz

06.03.2007, 22:23

naja, im fall von einem würfel ist das mit den normalen eigentlich kein problem...einfach für jeden vertex angeben, gleich wie die position.

dein algorithmus wird vermutlich funktionieren, abgesehen davon, dass die normierung fehlt. normalvektoren müssen die länge 1 haben (sonst ist die beleuchtung nicht unbedingt was man erwarten würde

). zwar kannst du d3d das machen lassen, das würd ich aber lassen, da nicht unbedingt förderlich für die performance (und einfach zu vermeiden).

dein problem wird am ehesten sein, dass die normalen nicht das angeben, was du gerne hättest. deine würfel bestehen nur aus 8 vertices. 6 dreiecke teilen sich ein vertex, wobei immer 2 dreiecke davon andere normalvektoren haben. die einzige lösung ist, mehrere vertices zu verwenden (24), damit jedes dreieck seinen richtigen normalvektor haben kann...