Visibilità di una struct

[ercand]

y.a.f.ake ha scritto ven, 07 aprile 2006 alle 11:52
In che senso ti da errore? A tempo di compilazione o solleva qualche eccezione/memory fault durante l'esecuzione? ho compilato il codice su e non mi da nessun errore

l'errore è precisamente:

Unhandled exception at 0x00452416 in Mio_Progetto.exe: 0xC0000005: Access violation writing location 0x3f800010.


ragionandoci sopra mi era venuta questa idea, la funzione che riempe la struct è questa:
HRESULT Lock(
UINT OffsetToLock,
UINT SizeToLock,
VOID ** ppbData,
DWORD Flags
);

secondo me il paramentro che crea problemi è il terzo, cioè:

ppbData
[out] VOID* pointer to a memory buffer containing the returned vertex data.

a questa parametro, se ho capito un minimo i puntatori, gli dobbiamo passare l'indirizzo di memoria del puntatore alla struct cioè &m_pCloneVerticiFVF , e lui poi la riempi in modo "lineare", l'errore potrebbe essere dato dal fatto che mentre riempe la struct incontra un secondo puntatore D3DXVECTOR* Texture che fa riferimento a un'altro indirizzo di memoria non consecutivo al primo, quindi la struct non può più essere riempita in maniera "lineare" e da un errore, che ne pensi può essere un ragionameto esatto??

[y.a.f.ake]

[sparominchiate perchè non so una mazza di DX mode ON]
Il buffer non lo devi inizializzare tu ma te lo restuisce lui

[y.a.f.ake]

Mi pare di capire che prima si crea un interfaccia IDirect3DVertexBuffer9 tramite CreateVertexBuffer e qui si specifica il formato dei vertici nel buffer nel tuo caso sarebbe
dwFVF = ( D3DFVF_XYZ | D3DFVF_NORMAL |D3DFVF_TEX3);
e poi si utilizza la lock passandogli un puntatore non inizializzato alla struttura da te definita.
eccoti un esempio trovato in rete:
struct Vertex
{
FLOAT x, y, z;
FLOAT nx, ny, nz;
};

const DWORD VertexFVF = (D3DFVF_XYZ | D3DFVF_DIFFUSE);

g_pDevice->CreateVertexBuffer(4*sizeof(Vertex), D3DUSAGE_WRITEONLY, VertexFVF,
D3DPOOL_DEFAULT, &pVB, NULL);

Vertex *pV;
pVB->Lock(0, 0, reinterpret_cast<void**>(&pV), 0);

pV[0].x = 0.0f; pV[0].y = 0.5; pV[0].z = 3.0f;
pV[0].diffuse = 0xffffffff;

pV[1].x = 1.0f; pV[1].y = -0.5f; pV[1].z = 4.0f;
pV[1].diffuse = 0xff777777;

pV[2].x = -1.0f; pV[2].y = -0.5f; pV[2].z = 4.0f;
pV[2].diffuse = 0xff777777;

pV[3].x = 0.0f; pV[3].y = -0.5f; pV[3].z = 2.0f;
pV[3].diffuse = 0xff000000;

pVB->Unlock();

[ercand]

y.a.f.ake ha scritto ven, 07 aprile 2006 alle 18:30

[sparominchiate perchè non so una mazza di DX mode ON]
Il buffer non lo devi inizializzare tu ma te lo restuisce lui

il buffer che deve contenre i vertici è questo:
LPDIRECT3DVERTEXBUFFER9 m_pCloneVertexBufferFVF = NULL;

poi lo riempo attraverso questa( m_pMesh è la variabile che indica il modello 3d da cui voglio prendere i dati):

HRESULT GetVertexBuffer( LPDIRECT3DVERTEXBUFFER9 * ppVB );
Parameters
ppVB
[out, retval] Address of a pointer to an IDirect3DVertexBuffer9 interface, representing the vertex buffer object associated with the mesh.

m_pMesh-> GetVertexBuffer(&m_pCloneVertexBuffe rFVF);

e poi riempo la strusct con questa:
m_pCloneVertexBufferFVF->Lock(0,m_pMesh- >GetNumVertices() * sizeof(MESH_VERTEX_CLONEFVF), (void**)&m_pCloneVerticiFVF, 0);

ed è quest'ultima che crea il rpoblema

[ercand]

y.a.f.ake ha scritto ven, 07 aprile 2006 alle 19:02
Mi pare di capire che prima si crea un interfaccia IDirect3DVertexBuffer9 tramite CreateVertexBuffer e qui si specifica il formato dei vertici nel buffer nel tuo caso sarebbe
dwFVF = ( D3DFVF_XYZ | D3DFVF_NORMAL |D3DFVF_TEX3);
e poi si utilizza la lock passandogli un puntatore non inizializzato alla struttura da te definita.
eccoti un esempio trovato in rete:
struct Vertex
{
FLOAT x, y, z;
FLOAT nx, ny, nz;
};

const DWORD VertexFVF = (D3DFVF_XYZ | D3DFVF_DIFFUSE);

g_pDevice->CreateVertexBuffer(4*sizeof(Vertex), D3DUSAGE_WRITEONLY, VertexFVF,
D3DPOOL_DEFAULT, &pVB, NULL);

Vertex *pV;
pVB->Lock(0, 0, reinterpret_cast<void**>(&pV), 0);

pV[0].x = 0.0f; pV[0].y = 0.5; pV[0].z = 3.0f;
pV[0].diffuse = 0xffffffff;

pV[1].x = 1.0f; pV[1].y = -0.5f; pV[1].z = 4.0f;
pV[1].diffuse = 0xff777777;

pV[2].x = -1.0f; pV[2].y = -0.5f; pV[2].z = 4.0f;
pV[2].diffuse = 0xff777777;

pV[3].x = 0.0f; pV[3].y = -0.5f; pV[3].z = 2.0f;
pV[3].diffuse = 0xff000000;

pVB->Unlock();

è leggermente differente perchè nel tuo esempio il buffer lo crei te e lo imposti te, questo procedimento che hai postato si fa per creare dei modellini semplicissimi ( tipo quadrati come quello che hai scritto), però quando voui usare modelli con 5000 poligoni fare un lavoro come il tuo esempio è impossibile e allora si usa un formato gia prondo messo a disposizione dalle stesse DirectX.

ps. il posto precedente a questo spiega le funzioni che uso

[ercand]

ragassi qualcuno che mi aiuti per favore

[y.a.f.ake]

Beh se l'access violation avviene nella funzione m_pCloneVertexBufferFVF->Lock è probabile che il numero m_pMesh- >GetNumVertices() * sizeof(MESH_VERTEX_CLONEFVF) sia più grande del la dimensione del vertex buffer, scusa quanto è grande il vertex buffer puoi saperlo prima no? e puoi controllare se m_pMesh- >GetNumVertices() * sizeof(MESH_VERTEX_CLONEFVF) è effetivamente minore o al massimo uguale alla dimensione del vertex buffer.

[ercand]

y.a.f.ake ha scritto lun, 10 aprile 2006 alle 18:15
Beh se l'access violation avviene nella funzione m_pCloneVertexBufferFVF->Lock è probabile che il numero m_pMesh- >GetNumVertices() * sizeof(MESH_VERTEX_CLONEFVF) sia più grande del la dimensione del vertex buffer, scusa quanto è grande il vertex buffer puoi saperlo prima no? e puoi controllare se m_pMesh- >GetNumVertices() * sizeof(MESH_VERTEX_CLONEFVF) è effetivamente minore o al massimo uguale alla dimensione del vertex buffer.

provondo a trovare la dimensione ho fatto questo calcolo:
D3DXVECTOR3 posizione, normale; sono 6 float quindi 12+12
D3DXVECTOR2 *Texture lo inizializzo a 3 coppie di due float quindi 8+8+8.

in totale dovrebbe essere 48, ho provato a metterlo ma da sempre il solito errore

non so se lo hai letto ( quindi lo quoto ), ma secondo te questo ragionamento puo avere un senso???

Quote:

ragionandoci sopra mi era venuta questa idea, la funzione che riempe la struct è questa:
HRESULT Lock(
UINT OffsetToLock,
UINT SizeToLock,
VOID ** ppbData,
DWORD Flags
);

secondo me il paramentro che crea problemi è il terzo, cioè:

ppbData
[out] VOID* pointer to a memory buffer containing the returned vertex data.

a questa parametro, se ho capito un minimo i puntatori, gli dobbiamo passare l'indirizzo di memoria del puntatore alla struct cioè &m_pCloneVerticiFVF , e lui poi la riempi in modo "lineare", l'errore potrebbe essere dato dal fatto che mentre riempe la struct incontra un secondo puntatore D3DXVECTOR* Texture che fa riferimento a un'altro indirizzo di memoria non consecutivo al primo, quindi la struct non può più essere riempita in maniera "lineare" e da un errore, che ne pensi può essere un ragionameto esatto??

[y.a.f.ake]

No perchè come vedi quando gli passi il puntatore fai un cast ad un void *, quindi nella funzione lui vede semplicemente quel tipo di puntatore.
Se ho ben capito questa funzione scarica un buffer dalla scheda video e lo riversa in un buffer che lui crea in memoria e di cui ti restituisce il puntatore, perchè alla Lock non gli passi 0 invece di m_pMesh- >GetNumVertices() * sizeof(MESH_VERTEX_CLONEFVF) in modo da restituirti tutto il buffer?

Ho spulciato fra i metodi dell'interfaccia ID3DXMesh e queste funzioni non ti potrebbero essere di aiuto?
GetFVF e GetNumBytesPerVertex per sapere il formato dei vertici e quindi utilizzare un struttura adeguata per accedervi.

Che differenza c'è fra l'utilizzare la coppia GetVertexBuffer e lock ed utilizzare LockVertexBuffer ?

edit:
Più correttamente( ) dovrebbe essere così:
MESH_VERTEX_CLONEFVF* m_pCloneVerticiFVF;
void ** data;
m_pCloneVertexBufferFVF->Lock(0,0, data, 0);

m_pCloneVerticiFVF= (MESH_VERTEX_CLONEFVF*)*data;

m_pCloneVerticiFVF sarebbe a questo punto un array di grandezza GetNumVertices() di struct, dove la singola struct dovrebbe essere definita in sintonia con GetFVF e GetNumBytesPerVertex,

[ercand]

y.a.f.ake ha scritto mar, 11 aprile 2006 alle 08:30
No perchè come vedi quando gli passi il puntatore fai un cast ad un void *, quindi nella funzione lui vede semplicemente quel tipo di puntatore.
Se ho ben capito questa funzione scarica un buffer dalla scheda video e lo riversa in un buffer che lui crea in memoria e di cui ti restituisce il puntatore, perchè alla Lock non gli passi 0 invece di m_pMesh- >GetNumVertices() * sizeof(MESH_VERTEX_CLONEFVF) in modo da restituirti tutto il buffer?

Ho spulciato fra i metodi dell'interfaccia ID3DXMesh e queste funzioni non ti potrebbero essere di aiuto?
GetFVF e GetNumBytesPerVertex per sapere il formato dei vertici e quindi utilizzare un struttura adeguata per accedervi.

Che differenza c'è fra l'utilizzare la coppia GetVertexBuffer e lock ed utilizzare LockVertexBuffer ?

edit:
Più correttamente( ) dovrebbe essere così:
MESH_VERTEX_CLONEFVF* m_pCloneVerticiFVF;
void ** data;
m_pCloneVertexBufferFVF->Lock(0,0, data, 0);

m_pCloneVerticiFVF= (MESH_VERTEX_CLONEFVF*)*data;

m_pCloneVerticiFVF sarebbe a questo punto un array di grandezza GetNumVertices() di struct, dove la singola struct dovrebbe essere definita in sintonia con GetFVF e GetNumBytesPerVertex,

ciao, ho provato a fare come hai detto:

VOID *Dati = NULL; //se scrivo VOID** da errore

m_pCloneVertexBufferFVF->Lock(0 , 0, (void**)&Dati, 0);

poi copio cio che c'è dentro Dati nella struct

memcpy(m_pCloneVerticiFVF, Dati, m_pMesh->GetNumVertices() * sizeof(MESH_VERTEX_CLONEFVF));

per quanto riguarda la dimensione di memcpy ho fatto varie prove ma da comunque errore incomincio a perdere le speranze

[Zan-Shi]

Non darti per vinto!

Anche io, come te, sto cominciando a programmare un piccolo motore grafico 3D (è per questo che ho, momentaneamente, abbandonato il mondo del modding) e, ti posso assicurare, che finché non avrai una certa esperienza errori di questo tipo si ripresenteranno spesso.

Purtroppo non posso dare una soluzione diretta al tuo problema, dato che io mi sto specializzando con le OpenGL e tu, a quanto ho capito, usi DitectX, ma posso darti un consiglio: prima di cimentarti con la grafica impara ad usare bene il C/C++; solo una volta che avrai imparato a padroneggiare il linguaggio potrai passare alla programmazione 3D. Non puoi pensate di imparare a due cose così complicate (C e DiretX) contemporaneamente.

Meglio fare un passetto alla volta, altrimenti si rischia di inciampare.

[ercand]

so che bisognerebbe studiare prima il linguaggio di programmazione per bene, ma capisci anche che studiare da soli c++ è abbastanza pesante, ma se insieme provo a fare un qualcosa che mi paice ( engine ) si ha una maggior voglia di applicarsi e di nn arrendersi alle prime difficoltà.

[y.a.f.ake]

Ho installato l'sdk delle DX e ho giocato un pò... vedi se puoi prendere spunto da questo codice, al netto di rincitronimenti miei dovrebbe avere un senso:

   
//union per accedere ai membri del buffer se ti serve accedere a dati D3DXVECTOR3 utilizzi xyz sennò xy 
union MESH_VERTEX_CLONEFVF{  
    D3DXVECTOR3 *xyz;
    D3DXVECTOR2 *xy;
};

MESH_VERTEX_CLONEFVF temp;

int posizione_pos=0;
int posizione_tex=1;  
/* posizione delle coordinate delle texture
nel buffer.Questa deve essere nota a
priori: se ad esempio il buffer è 
costuito da posizione e texture allora 
è 1 se è cosituito da posizione,normale 
e texture allora è 2 e così via */  


DWORD tipofvf= g_pMesh->GetFVF();

int numtex=tipofvf>>D3DFVF_TEXCOUNT_SHIFT;  //numero di texture

unsigned char * vertici;		 

if(!FAILED(g_pMesh->LockVertexBuffer(0,(void**)&vertici))){
	   
  
   for (long i = 0; i < (long)g_pMesh->GetNumVertices(); i++)
       {
         temp.xyz=(D3DXVECTOR3 *)(vertici + g_pMesh->GetNumBytesPerVertex()*i); //accedo alla posizione
         temp.xyz[posizione_pos].x=temp.xyz[posizione_pos].z;
				
	 temp.xy=(D3DXVECTOR2 *)(temp.xyz+posizione_tex); //accedo alle texture
	   
        for (int j=0;j<numtex;j++){

             
           temp.xy[j].x=temp.xy[j].y;

				  
	    }
            
      } 
		 
  g_pMesh->UnlockVertexBuffer();
		
		}

[Edward Gein]

ercand ha scritto mer, 12 aprile 2006 alle 19:45
so che bisognerebbe studiare prima il linguaggio di programmazione per bene, ma capisci anche che studiare da soli c++ è abbastanza pesante, ma se insieme provo a fare un qualcosa che mi paice ( engine ) si ha una maggior voglia di applicarsi e di nn arrendersi alle prime difficoltà.

Si, ma non puoi mai creare un motore 3D se non conosci concetti base come l'allocazione dinamica di memoria e simili.

Ti consiglio di partire dalle basi, per quanto pallose possano essere.

[ercand]

y.a.f.ake ha scritto ven, 14 aprile 2006 alle 12:59
Ho installato l'sdk delle DX e ho giocato un pò... vedi se puoi prendere spunto da questo codice, al netto di rincitronimenti miei dovrebbe avere un senso:

   
//union per accedere ai membri del buffer se ti serve accedere a dati D3DXVECTOR3 utilizzi xyz sennò xy 
union MESH_VERTEX_CLONEFVF{  
    D3DXVECTOR3 *xyz;
    D3DXVECTOR2 *xy;
};

MESH_VERTEX_CLONEFVF temp;

int posizione_pos=0;
int posizione_tex=1;  
/* posizione delle coordinate delle texture
nel buffer.Questa deve essere nota a
priori: se ad esempio il buffer è 
costuito da posizione e texture allora 
è 1 se è cosituito da posizione,normale 
e texture allora è 2 e così via */  


DWORD tipofvf= g_pMesh->GetFVF();

int numtex=tipofvf>>D3DFVF_TEXCOUNT_SHIFT;  //numero di texture

void * vertici;		 

if(!FAILED(g_pMesh->LockVertexBuffer(0,(void**)&vertici))){
	   
  
   for (long i = 0; i < (long)g_pMesh->GetNumVertices(); i++)
       {
         temp.xyz=(D3DXVECTOR3 *)vertici+i; //accedo alla posizione
         temp.xyz[posizione_pos].x=temp.xyz[posizione_pos].z;
				
	  temp.xy=(D3DXVECTOR2 *)vertici+i; //accedo alle texture
	   
        for (int j=0;j<numtex;j++){

             
           temp.xy[posizione_tex+j].x=temp.xy[posizione_tex+j].y;

				  
	    }
            
      } 
		 
  g_pMesh->UnlockVertexBuffer();
		
		}

adesso farò una prova e ti dico se mi funziona

Edward Gein

Si, ma non puoi mai creare un motore 3D se non conosci concetti base come l'allocazione dinamica di memoria e simili.

Ti consiglio di partire dalle basi, per quanto pallose possano essere.

so che hai ragione ma per me dedicarmi al c++ per me sarebbe troppo pesante

[y.a.f.ake]

ho editato, dovrebbe essere la versione corretta

[ercand]

ciau, rieccomi qua .

y.a.f.ake ho provato a fare come hai scritto ma mi da degli errori, e io sinceramente non ho ben capito il significato di quello che hai scritto (sembra che lavori sugli indirizzi di memoria ma non sono sicuro), comunque ho chiesto in un forum dove si programma giochi e mi hanno dato questa soiegazione:

Quote:

Non si può venerdì mi spiace. Una copia di basso livello come Lock() non ha la minima idea del fatto che tu abbia o no un puntatore sulla tua struttura. Non puoi fare una cosa del genere in C, sarebbe troppo facile. Mi spiego meglio:

1. struct MESH_VERTEX_CLONEFVF
2. {
3. D3DXVECTOR3 posizione, normale;
4. D3DXVECTOR2* Texture;
5. };



Texture è un intero a 32 bit nelle macchine intel, se io ho un array di queste strutture avrò la memoria organizzata così:
[posizione.x][posizione.y][posizione.z][ Texture][posizione.x]
dove ogni parentesi racchiude 32 bit. Ora se tu hai una struttura del tipo:

1. struct MESH_VERTEX_CLONEFVF
2. {
3. D3DXVECTOR3 posizione, normale;
4. D3DXVECTOR2 Texture[3];
5. };



essa è organizzata in memoria così:
[posizione.x][posizione.y][posizione.z][ Texture1.u][Texture1.v][Texture2.u][Text ure2.v][Texture3.u][Texture3.v]...
è ovvio che se si effettua una copia raw di memoria succedono cose molto pericolose:
[posizione.x][posizione.y][posizione.z][ Texture][posizione.x]
[posizione.x][posizione.y][posizione.z][ Texture1.u][Texture1.v][Texture2.u][Text ure2.v][Texture3.u][Texture3.v]
ovvero la memoria viene disallineata. Non puoi mettere un puntatore su una struttura ed aspettarti che tutto fili liscio quando c'è memcpy di mezzo.
Prova a cambiare il codice con questo in mente.

e ora vi spiego il problema che sto incontrando ora: praticamente ho deciso di creare la struct ogni volta che chiamo la funzione, la funziona è questa:

Quote:

VOID FunzioniMesh::ModificaCordinateTextureFV F(float TU, float TV, int NumeroTexture, int IndiceTexture)
{

struct MESH_VERTEX_CLONEFVF{D3DXVECTOR3 posizione, normale;
D3DXVECTOR2 Texture[NumeroTexture];
};
MESH_VERTEX_CLONEFVF* m_pCloneVerticiFVF;

m_pCloneVertexBufferFVF->Lock(0, m_pMesh->GetNumVertices() * sizeof(MESH_VERTEX_CLONEFVF), (void**)&m_pCloneVerticiFVF, 0);

for (int i = 0; i < m_pMesh->GetNumVertices(); i++)
{
m_pCloneVerticiFVF[i].Texture[IndiceText ure].x += TU;
m_pCloneVerticiFVF[i].Texture[IndiceText ure].y += TV;
}

m_pCloneVertexBufferFVF->Unlock();
}

ma se provo a compilare mi da un errore su D3DXVECTOR2 Texture[NumeroTexture]; e l'errore è il seguente: c:\progetto\mio progetto\mesh.cpp(780) : error C2057: expected constant expression
c:\progetto\mio progetto\mesh.cpp(780) : warning C4200: nonstandard extension used : zero-sized array in struct/union
Cannot generate copy-ctor or copy-assignment operator when UDT contains a zero-sized array

mi potreste illuminare su questo errore?

grazie e ciao

[y.a.f.ake]

ma che io sappia questa cosa non si può fare:

Quote:

VOID FunzioniMesh::ModificaCordinateTextureFV F(float TU, float TV, int NumeroTexture , int IndiceTexture)
{

struct MESH_VERTEX_CLONEFVF{D3DXVECTOR3 posizione, normale;
D3DXVECTOR2 Texture[NumeroTexture];
};

e pare che il compilatore sia d'accordo...
vieni per caso da Java tu?

mentre quello che ti ho scritto io lo ho testato e funziona, ho fatto test con il debugger su un modello di cui ne conoscevo i vertici e ci si è spostato bene sopra... beh forse il codice può essere reso più elegente e semplificato,
ma la questione si può riassumere così:
-La funzione Lock ti restituisce un buffer di memoria, quindi tu non devi allocare un bel niente ne staticamente ne dinamicamente, devi solo passargli una variabile puntatore di memoria che la funzione provvederà a riempire con l'indirizzo di memoria del buffer;
-Di questo buffer di memoria non ne conosci la esatta struttura a priori, quindi il problema è quello di utilizzare oppurtuni puntatori e calcoli per poter accedere ai dati.

Vediamo se si possono semplificare questi calcoli:
C'è da dire che il più delle volte questo buffer può essere visto come un grande array di float di grandezza GetNumVertices()*(GetNumBytesPerVerte) /sizeof(float))
Quindi in teoria (è da verificare) puoi accedere alle coordinate con un solo float* ,
sostanzialmente GetNumBytesPerVerte)/sizeof(float) ti dice ogni vertice da quanti float è composto e se per esempio ti dice che è composto da 5 float (una tripla per le coordinate ed una coppia per texture) allora puoi accedervi cosi:
float* vertice;
LockVertexBuffer(0,(void**)&vertice)
vertice[0] // la coord x
vertice[1] // la coord y
vertice[2] // la coord z
vertice[3] // la text coord x
vertice[4] // la text coord y

per accedere al prossimo vertice
vertice=vertice+(GetNumBytesPerVerte)/ sizeof(float));

[ercand]

ciao

y.a.f.ake ha scritto sab, 29 aprile 2006 alle 10:17
ma che io sappia questa cosa non si può fare:

Quote:

VOID FunzioniMesh::ModificaCordinateTextureFV F(float TU, float TV, int NumeroTexture , int IndiceTexture)
{

struct MESH_VERTEX_CLONEFVF{D3DXVECTOR3 posizione, normale;
D3DXVECTOR2 Texture[NumeroTexture];
};

e pare che il compilatore sia d'accordo...
vieni per caso da Java tu?

no non vengo da java, io vengo da zero

Quote:

mentre quello che ti ho scritto io lo ho testato e funziona, ho fatto test con il debugger su un modello di cui ne conoscevo i vertici e ci si è spostato bene sopra... beh forse il codice può essere reso più elegente e semplificato,
ma la questione si può riassumere così:
-La funzione Lock ti restituisce un buffer di memoria, quindi tu non devi allocare un bel niente ne staticamente ne dinamicamente, devi solo passargli una variabile puntatore di memoria che la funzione provvederà a riempire con l'indirizzo di memoria del buffer;
-Di questo buffer di memoria non ne conosci la esatta struttura a priori, quindi il problema è quello di utilizzare oppurtuni puntatori e calcoli per poter accedere ai dati.

Vediamo se si possono semplificare questi calcoli:
C'è da dire che il più delle volte questo buffer può essere visto come un grande array di float di grandezza GetNumVertices()*(GetNumBytesPerVerte) /sizeof(float))
Quindi in teoria (è da verificare) puoi accedere alle coordinate con un solo float* ,
sostanzialmente GetNumBytesPerVerte)/sizeof(float) ti dice ogni vertice da quanti float è composto e se per esempio ti dice che è composto da 5 float (una tripla per le coordinate ed una coppia per texture) allora puoi accedervi cosi:
float* vertice;
LockVertexBuffer(0,(void**)&vertice)
vertice[0] // la coord x
vertice[1] // la coord y
vertice[2] // la coord z
vertice[3] // la text coord x
vertice[4] // la text coord y

per accedere al prossimo vertice
vertice=vertice+(GetNumBytesPerVerte)/ sizeof(float));

ho fatto delle prove e dopo un po di orette sono riuscito a farlo funzionare, e lo trovo anche più comodo rispoetto a struct con i suoi puntatori e tutto il resto , grazie a tutti per l'aiutone che mi avete dato