void GPUData::InitWithoutBufferSetup(EffectID aEffect, int aVertexStride, GPUContext& aGPUContext, AssetContainer& aAssetContainer)
{
InitInputLayout(aEffect, aGPUContext, aAssetContainer);
InitVertexBuffer(aVertexStride, D3D11_USAGE_IMMUTABLE, 0);
InitIndexBuffer();
myIndexData = new IndexData();
myVertexData = new VertexData();
SetTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
myTechniqueName = "Render";
}
int main(int argc, char** argv)
{
//--Foodweb Struktur mit Standardwerten aufstellen------------------------------------------------------------------------------------------
struct simuParams simParams = {0.3, 0.65, 0.35, 0.5, 6.0}; // Diese Parameter sind konstant
struct simuMemory simMem = {NULL, NULL, NULL, NULL, NULL}; // Größe der Vektoren liegt noch nicht fest
gsl_vector* fixpunkte = gsl_vector_calloc(9);
struct foodweb nicheweb = {NULL, fixpunkte, NULL,&simParams, &simMem, 18, 3, 1, 5, 0, 0, -7., 0.0, 0, 1}; // Reihenfolge: network, fxpkt, migrPara, AllMus, AllNus, S, B, Rnum, Y, T, Tchoice, d, x, M, Z
struct migration stochastic = {NULL, NULL, NULL, NULL, NULL, NULL, 0.00001, NULL, NULL, NULL, NULL, NULL};
struct resource res = {500.0, 0.0}; // Resource: Größe, Wachstum
//--Konsoleneingabe-------------------------------------------------------------------------------------------------------------------------
int L = 5; // Statistik
int i = 0,j; // Counter
char aims6[255] = ORT;
FILE* RobustnessEachRun;
int checksum = getArgs(argc, argv, &(nicheweb.S), &(nicheweb.B), &(nicheweb.T), &(nicheweb.d), &L, &(nicheweb.Y), &(nicheweb.x), &(nicheweb.M), &(res.size), &(nicheweb.Z), &(stochastic.Bmigr));
if (checksum != 11 && checksum!=(int)(argc-1)/2) // Alles gesetzt?
{
printf("Bitte gültige Eingabe für Parameter machen!\nProgramm wird beendet.\n");
return(0);
}
/* int length = ((nicheweb.Rnum+nicheweb.S)*(nicheweb.S+nicheweb.Rnum)+1+nicheweb.Y*nicheweb.Y+1+(nicheweb.Rnum+nicheweb.S)+nicheweb.S+1); // Länge des Rückabewerts
nicheweb.network = gsl_vector_calloc(length);
*/
// Speicher belegen, nachdem die Größe des Systems durch die Konsoleneingabe bekannt ist
CallocFoodwebMem(&nicheweb);
CallocStochasticMem(&stochastic, nicheweb.Y, nicheweb.S);
printf("Z = %i\n",nicheweb.Z);
nicheweb.migrPara = gsl_vector_calloc(7); // Reihenfolge: tau, mu, nu, SpeciesNumber, momentanes t, ymigr, migrationEventNumber
// stochastic.SpeciesNumbers = gsl_vector_calloc(nicheweb.Z);
// stochastic.AllMus = gsl_vector_calloc(nicheweb.Z);
// stochastic.AllNus = gsl_vector_calloc(nicheweb.Z);
// stochastic.Biomass_SpeciesNumbers = gsl_vector_calloc(nicheweb.Z);
// stochastic.Biomass_AllMus = gsl_vector_calloc(nicheweb.Z);
// stochastic.Biomass_AllNus = gsl_vector_calloc(nicheweb.Z);
//--Zufallszahlengenerator initialisieren--------------------------------------------------------------------------------
const gsl_rng_type *rng1_T; // ****
gsl_rng *rng1; // initialize random number generator
gsl_rng_env_setup(); // ermöglicht Konsolenparameter
rng1_T = gsl_rng_default; // default random number generator (so called mt19937)
gsl_rng_default_seed = 0; // default seed for rng
// gsl_rng_default_seed = ((unsigned)time(NULL)); // random starting seed for rng
rng1 = gsl_rng_alloc(rng1_T);
//--Struct initialisieren für patchweise Ausgabe----------------------------------------------------------------------------------------
struct data patchwise[nicheweb.Y];
for(i=0; i<nicheweb.Y; i++)
{
gsl_vector* sini = gsl_vector_calloc(6);
gsl_vector* sfini = gsl_vector_calloc(6);
gsl_vector* bini = gsl_vector_calloc(6);
gsl_vector* bfini = gsl_vector_calloc(6);
gsl_vector* robness = gsl_vector_calloc(2);
//struct data tempo = {sini,sfini,bini,bfini,robness};
struct data temp = {sini,sfini,bini,bfini,robness};
patchwise[i] = temp;
}
//printf("test");
//--Initialisierungen---------------------------------------------------------------------------------------------------
nicheweb.Tchoice = nicheweb.T;
nicheweb.T = 0;
nicheweb.d = nicheweb.d/10;
printf("d ist %f\n",nicheweb.d);
res.size = res.size/10;
stochastic.Bmigr = 2.5*stochastic.Bmigr*pow(10,nicheweb.d);
nicheweb.Z = pow(10,nicheweb.Z);
printf("Bmigr ist %f\n",stochastic.Bmigr);
printf("Z ist %i\n",nicheweb.Z);
printf("x ist %f\n",nicheweb.x);
//int len = ((nicheweb.Rnum+nicheweb.S)*(nicheweb.S+nicheweb.Rnum)+1+nicheweb.Y*nicheweb.Y+1+(nicheweb.Rnum+nicheweb.S)+nicheweb.S); // Länge des Rückabewerts
gsl_vector *populationFIN = gsl_vector_calloc((nicheweb.Rnum + nicheweb.S)*(nicheweb.Y)*5 + (nicheweb.S) + 3); // Gleiche Länge wie Rückgabe von evolveNetwork
gsl_vector *robustness = gsl_vector_calloc(63);
gsl_vector *resultEvolveWeb = gsl_vector_calloc((nicheweb.Rnum+nicheweb.S)*nicheweb.Y*5 + 3 + nicheweb.S); // y[Simulation], y0, ymax, ymin, yavg, fixp, TL
gsl_vector *resultRobustness = gsl_vector_calloc(63);
gsl_matrix *D = gsl_matrix_calloc(nicheweb.Y,nicheweb.Y);
gsl_matrix* Dchoice = gsl_matrix_calloc(nicheweb.Y,nicheweb.Y);
gsl_vector *robustnesstemp = gsl_vector_calloc(63);
gsl_vector *meanSquOfDataAll = gsl_vector_calloc(63);
gsl_vector *meanSquOfDataAlltemp = gsl_vector_calloc(63);
gsl_vector *standardDeviationAll = gsl_vector_calloc(63);
gsl_vector *meanOfData = gsl_vector_calloc((6*4+2)*nicheweb.Y);
gsl_vector *meanOfDatatemp = gsl_vector_calloc((6*4+2)*nicheweb.Y);
gsl_vector *meanSquOfData = gsl_vector_calloc((6*4+2)*nicheweb.Y);
gsl_vector *standardDeviation = gsl_vector_calloc((6*4+2)*nicheweb.Y);
gsl_vector_set_zero(robustness);
gsl_vector_set_zero(meanOfData);
gsl_vector_set_zero(meanSquOfData);
gsl_vector_set_zero(nicheweb.migrPara);
gsl_vector_set_zero(meanSquOfDataAll);
// double SpeciesNumber[L*nicheweb.Z][2];
// double AllMu[L*nicheweb.Z][2];
// double AllNu[L*nicheweb.Z][2];
double ymigr = 0;
double mu = 0;
double nu = 0;
double ymigrtemp;
double ymigrSqu = 0;
double ymigrDeviation;
double migrationEventNumber = 0;
double migrationEventNumbertemp;
double migrationEventNumberSqu = 0.0;
double migrationEventNumberDeviation;
int lastMigrationEventNumber = 0;
//--Simulation---------------------------------------------------------------------------------------------------------------------
//SetTopology(nicheweb.Y, nicheweb.T, D);
SetTopology(nicheweb.Y, nicheweb.Tchoice, Dchoice);
// for(i = 0; i<nicheweb.Y; i++)
// {
// for(j = 0 ; j<nicheweb.Y; j++)
// {
// printf("%f\t",gsl_matrix_get(Dchoice,i,j));
// }
// printf("\n");
// }
for(i = 0; i < L; i++)
{
// const gsl_rng_type *rng1_T; // ****
// gsl_rng *rng1; // initialize random number generator
// gsl_rng_env_setup(); // ermöglicht Konsolenparameter
// rng1_T = gsl_rng_default; // default random number generator (so called mt19937)
// gsl_rng_default_seed = 0; // default seed for rng
// //gsl_rng_default_seed = ((unsigned)time(NULL)); // random starting seed for rng
// rng1 = gsl_rng_alloc(rng1_T);
printf("\nStarte Durchlauf L = %i\n", i);
//--Starte Simulation-----------------------------------------------------------------------------------------------
SetNicheNetwork(nicheweb, stochastic, res, rng1, rng1_T, D);
gsl_vector_set_zero(resultEvolveWeb);
populationFIN = EvolveNetwork(nicheweb, stochastic, rng1, rng1_T, Dchoice, resultEvolveWeb);
gsl_vector_set_zero(resultRobustness);
gsl_vector_memcpy(robustnesstemp, EvaluateRobustness(populationFIN, nicheweb, patchwise, resultRobustness)); // Robustness Analyse
//--Standardabweichung für Mittelung vorbereiten-----------------------------------------------------------------------------------------
determineMean(robustnesstemp, 63, robustness);
determineMeanSqu(robustnesstemp, 63, meanSquOfDataAll);
//--Ausgabewerte----------------------------------------------------------------------------------------------------------
ymigrtemp = gsl_vector_get(nicheweb.migrPara, 5);
migrationEventNumbertemp = gsl_vector_get(nicheweb.migrPara, 6);
// for(int j= 0; j<migrationEventNumbertemp; j++)
// {
// AllMu[lastMigrationEventNumber+j][0] = gsl_vector_get(stochastic.AllMus, j);
// AllNu[lastMigrationEventNumber+j][0] = gsl_vector_get(stochastic.AllNus, j);
// SpeciesNumber[lastMigrationEventNumber+j][0] = gsl_vector_get(stochastic.SpeciesNumbers,j);
//
// AllMu[lastMigrationEventNumber+j][1] = gsl_vector_get(stochastic.Biomass_AllMus, j);
// AllNu[lastMigrationEventNumber+j][1] = gsl_vector_get(stochastic.Biomass_AllNus, j);
// SpeciesNumber[lastMigrationEventNumber+j][1] = gsl_vector_get(stochastic.Biomass_SpeciesNumbers,j);
// }
lastMigrationEventNumber += migrationEventNumbertemp;
//printf("SpeciesNumber ist %f\n",SpeciesNumber[i]);
ymigr += ymigrtemp;
migrationEventNumber += migrationEventNumbertemp;
ymigrSqu += (ymigrtemp*ymigrtemp);
migrationEventNumberSqu = (migrationEventNumberSqu*(i)+(migrationEventNumbertemp*migrationEventNumbertemp))/(i+1);
// printf("Additionsteil ist %f\n",(migrationEventNumberSqu*(i)+(migrationEventNumbertemp*migrationEventNumbertemp))/(i+1));
//--Mittelwert und Vorbereitungen für Standardabweichung für die patchweise Ausgabe berechnen--------------------------------
linkElements(patchwise, nicheweb.Y, meanOfDatatemp);
determineMean(meanOfDatatemp, (6*4+2)*nicheweb.Y, meanOfData);
determineMeanSqu(meanOfDatatemp, (6*4+2)*nicheweb.Y, meanSquOfData);
createOutputRobustnessPatchwiseEachRun(nicheweb,patchwise,aims6,RobustnessEachRun,i);
printf("\nBeende Durchlauf L = %i\n", i);
}
//-- Standardabweichung berechnen--------------------------------------------------------------------------------------
ymigrSqu = ymigrSqu/L;
ymigr = ymigr/L;
ymigrDeviation = sqrt(ymigrSqu - ymigr*ymigr);
//migrationEventNumberSqu = migrationEventNumberSqu/L;
migrationEventNumber = migrationEventNumber/L;
migrationEventNumberDeviation = sqrt(migrationEventNumberSqu - migrationEventNumber*migrationEventNumber);
// printf("migrationEventNumber ist %f\n",migrationEventNumber);
// printf("migrationEventNumberSqu ist %f\n",migrationEventNumberSqu);
// printf("migrationEventNumberDeviation ist %f\n",migrationEventNumberDeviation);
//
//-- Für patchweise Ausgabe-------------------------------------------------------------------------------------------
standardDeviation = determineStandardDeviation((6*4+2)*nicheweb.Y, meanOfData, meanSquOfData, L, standardDeviation);
standardDeviationAll = determineStandardDeviation(63, robustness, meanSquOfDataAll, L, standardDeviationAll);
//printf("der 3. Eintrag in standardDeviationAll ist %f\n", gsl_vector_get(standardDeviationAll,3));
// printf("S ist %f\n", gsl_vector_get(robustness,3));
// printf("Standardabweichung von S ist %f\n", gsl_vector_get(standardDeviationAll,3));
// printf("meanOfDataSqu ist %f\n", gsl_vector_get(meanOfDataSquAll,3));
// printf("meanSquOfData ist %f\n", gsl_vector_get(meanSquOfDataAll,3));
printf("L=%i\tspeciesini=%f\tspeciesfinal=%f\n", L, gsl_vector_get(robustness, 3)/L, gsl_vector_get(robustness, 9)/L);
//--Abspeichern in File-------------------------------------------------------------------------------------
char aims[255] = ORT;
createOutputGeneral(nicheweb, res, stochastic, aims, robustness, standardDeviationAll, L, mu, nu, ymigr, ymigrDeviation, migrationEventNumber, migrationEventNumberDeviation); // Datei schließen
//--Daten patchweise abspeichern----------------------------------------------------------------------
// printf("population ist %f\n",gsl_vector_get(stochastic.Biomass_AllMus,0));
for(int l = 0 ; l< nicheweb.Y; l++)
{
//char name[100];
char aims2[255] = ORT2;
createOutputPatchwise(nicheweb, res, stochastic, aims2, meanOfData, standardDeviation, L, l);
}
// if(nicheweb.Tchoice != 0)
// {
//--Ausgewählte Spezies rausschreiben, die migrieren darf---------------------------------------------------------------------------
// char aims3[255] = ORT;
//
// //createOutputSpeciesNumber(nicheweb, res, aims3, SpeciesNumber, L, migrationEventNumber);
//
//
// //--Ausgewählte Verbindung rausschreiben, über die migriert werden darf---------------------------------------------------------------------------
//
// char aims4[255] = ORT;
//
// // createOutputPatchlink(nicheweb, res, aims4, AllMu, AllNu, L, migrationEventNumber);
// }
printf("\nSimulation abgespeichert\n\n");
//--free----------------------------------------------------------------------------------------------------------------
free(nicheweb.network);
gsl_vector_free(fixpunkte);
for(i=0; i<nicheweb.Y; i++)
{
gsl_vector_free(patchwise[i].sini);
gsl_vector_free(patchwise[i].sfini);
gsl_vector_free(patchwise[i].bini);
gsl_vector_free(patchwise[i].bfini);
gsl_vector_free(patchwise[i].robness);
}
FreeFoodwebMem(&nicheweb); // eigene Funktion
FreeStochasticMem(&stochastic);
gsl_vector_free(nicheweb.migrPara);
// gsl_vector_free(stochastic.AllMus);
// gsl_vector_free(stochastic.AllNus);
// gsl_vector_free(stochastic.SpeciesNumbers);
// gsl_vector_free(stochastic.Biomass_AllMus);
// gsl_vector_free(stochastic.Biomass_AllNus);
// gsl_vector_free(stochastic.Biomass_SpeciesNumbers);
gsl_vector_free(populationFIN);
gsl_vector_free(robustness);
gsl_vector_free(meanOfData);
gsl_vector_free(meanOfDatatemp);
gsl_vector_free(meanSquOfData);
gsl_vector_free(standardDeviation);
gsl_vector_free(standardDeviationAll);
gsl_vector_free(meanSquOfDataAll);
gsl_vector_free(meanSquOfDataAlltemp);
gsl_matrix_free(D);
gsl_matrix_free(Dchoice);
//gsl_vector_free(resultEvolveWeb);
gsl_vector_free(robustnesstemp);
gsl_rng_free(rng1);
return(0);
}
/*
Diese Funktion erstellt ein Nahrungsnetz nach dem Nischenmodell für S Spezies auf Y Lebensräumen, die über die Kopplungskonstante d verbunden sind. T gibt die Topologie an (siehe SetTopology). Rnum ist die Anzahl der Ressource(n) und Rsize die Startgröße der Ressource(n). C beschreibt die Konnektivität des Netzes, wobei CRange die erlaubte max. Abweichung von C angibt.
*/
gsl_vector *SetNicheNetwork(struct foodweb nicheweb, struct resource res, gsl_rng* rng1, const gsl_rng_type* rng1_T){
int len = ((nicheweb.Rnum+nicheweb.S)*(nicheweb.S+nicheweb.Rnum)+1+nicheweb.Y*nicheweb.Y+1+(nicheweb.Rnum+nicheweb.S)+nicheweb.S+3*(nicheweb.S)); // Länge des Rückabewerts
double C = 0.15; // vorgegebenes C
double CRange = 0.01;
double Rsize = res.size;
gsl_vector *result = gsl_vector_calloc(len);
gsl_matrix *NV = gsl_matrix_calloc(3, nicheweb.S);
gsl_matrix *A = gsl_matrix_calloc((nicheweb.Rnum+nicheweb.S),(nicheweb.S+nicheweb.Rnum));
gsl_matrix *mas = gsl_matrix_calloc(2, (nicheweb.Rnum+nicheweb.S));
printf("Erzeuge Nischennetz mit %i Spezies (davon gewünschte Anzahl basaler Spezies %i) auf %i Patches. Topologie-Marker %i.\n", nicheweb.S, nicheweb.B, nicheweb.Y, nicheweb.T);
//--Zufallszahlengenerator initialisieren--------------------------------------------------------------------------------
// const gsl_rng_type *rng1_T; // ****
// gsl_rng *rng1; // initialize random number generator
// gsl_rng_env_setup(); // ermöglicht Konsolenparameter
// rng1_T = gsl_rng_default; // default random number generator (so called mt19937)
// gsl_rng_default_seed = 0; // default seed for rng
// //gsl_rng_default_seed = ((unsigned)time(NULL)); // random starting seed for rng
// //gsl_rng_default_seed = (rdtsc());
// rng1 = gsl_rng_alloc(rng1_T);
//--Alle benötigten Daten ausrechnen--------------------------------------------------------------------------------------
int flag = 1;
int i = 0;
while(flag == 1)
{
flag = 0;
NV = SetNicheValues(nicheweb, C, rng1, rng1_T); // Nischenwerte NOTIZ: In den gsl Objekten liegen floats!
A = SetFeedingMatrix(nicheweb, NV, C, CRange); // interaction matrix
int links = CountLinks(A, (nicheweb.Rnum+nicheweb.S));
//printf("Prüfe Linkanzahl\n");
double CON = (double)links/(((double)nicheweb.S)*((double)nicheweb.S)-1);
if(CON < (C-CRange) || CON > (C+CRange))
{
flag = 1;
continue;
}
int bcount = 0;
for(i = nicheweb.Rnum; i< (nicheweb.S + nicheweb.Rnum); i++)
{
if(gsl_matrix_get(A, i, 0)==1)
bcount++;
}
if(bcount!=nicheweb.B)
{
flag = 1;
continue;
}
mas = SetMasses(nicheweb, NV, A, Rsize); // Massen + TL
int TL0 = 0;
for(i = 0; i< nicheweb.S; i++){
if(gsl_matrix_get(mas, 1, i+nicheweb.Rnum) == 0)
TL0++;
}
if(TL0!=0)
{
flag = 1;
continue;
}
}
for(i=0; i<nicheweb.S; i++) printf("Nischenwerte: %f\n", gsl_matrix_get(NV, 0, i));
gsl_matrix *D = SetTopology(nicheweb.Y, nicheweb.T); // migration matrix
result = LinkElements(nicheweb, NV, A, mas, D, Rsize, len);
printf("\nNetzwerk erfolgreich erzeugt!\n");
gsl_matrix_free(D);
gsl_matrix_free(NV);
gsl_matrix_free(A);
gsl_matrix_free(mas);
return result;
}
void GPUData::InitCube(EffectID aEffect, GPUContext& aGPUContext, AssetContainer& aAssetContainer)
{
#pragma region Vertices
CU::GrowingArray<VertexPosColor> vertices;
vertices.Init(24);
float size = 1.f;
float halfWidth = size / 2.f;
float halfHeight = size / 2.f;
float halfDepth = size / 2.f;
CU::Vector4<float> aColour(1.f, 1.f, 1.f, 1.f);
//0 - 3 (Top)
vertices.Add({ { -halfWidth, halfHeight, -halfDepth }, aColour });
vertices.Add({ { halfWidth, halfHeight, -halfDepth }, aColour });
vertices.Add({ { halfWidth, halfHeight, halfDepth }, aColour });
vertices.Add({ { -halfWidth, halfHeight, halfDepth }, aColour });
//4 - 7 (Bottom)
vertices.Add({ { -halfWidth, -halfHeight, -halfDepth }, aColour });
vertices.Add({ { halfWidth, -halfHeight, -halfDepth }, aColour });
vertices.Add({ { halfWidth, -halfHeight, halfDepth }, aColour });
vertices.Add({ { -halfWidth, -halfHeight, halfDepth }, aColour });
//8 - 11 (Left)
vertices.Add({ { -halfWidth, -halfHeight, halfDepth }, aColour });
vertices.Add({ { -halfWidth, -halfHeight, -halfDepth }, aColour });
vertices.Add({ { -halfWidth, halfHeight, -halfDepth }, aColour });
vertices.Add({ { -halfWidth, halfHeight, halfDepth }, aColour });
//12 - 15 (Right)
vertices.Add({ { halfWidth, -halfHeight, halfDepth }, aColour });
vertices.Add({ { halfWidth, -halfHeight, -halfDepth }, aColour });
vertices.Add({ { halfWidth, halfHeight, -halfDepth }, aColour });
vertices.Add({ { halfWidth, halfHeight, halfDepth }, aColour });
//16 - 19 (Front)
vertices.Add({ { -halfWidth, -halfHeight, -halfDepth }, aColour });
vertices.Add({ { halfWidth, -halfHeight, -halfDepth }, aColour });
vertices.Add({ { halfWidth, halfHeight, -halfDepth }, aColour });
vertices.Add({ { -halfWidth, halfHeight, -halfDepth }, aColour });
//20 - 23 (Back)
vertices.Add({ { -halfWidth, -halfHeight, halfDepth }, aColour });
vertices.Add({ { halfWidth, -halfHeight, halfDepth }, aColour });
vertices.Add({ { halfWidth, halfHeight, halfDepth }, aColour });
vertices.Add({ { -halfWidth, halfHeight, halfDepth }, aColour });
#pragma endregion
#pragma region Indices
CU::GrowingArray<int> indices(24);
//Top
indices.Add(3);
indices.Add(1);
indices.Add(0);
indices.Add(2);
indices.Add(1);
indices.Add(3);
//Bottom
indices.Add(6);
indices.Add(4);
indices.Add(5);
indices.Add(7);
indices.Add(4);
indices.Add(6);
//Left
indices.Add(11);
indices.Add(9);
indices.Add(8);
indices.Add(10);
indices.Add(9);
indices.Add(11);
//Right
indices.Add(14);
indices.Add(12);
indices.Add(13);
indices.Add(15);
indices.Add(12);
indices.Add(14);
//Front
indices.Add(19);
indices.Add(17);
indices.Add(16);
indices.Add(18);
indices.Add(17);
indices.Add(19);
//Back
indices.Add(22);
indices.Add(20);
indices.Add(21);
indices.Add(23);
indices.Add(20);
indices.Add(22);
#pragma endregion
SetTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
AddInputElement(new D3D11_INPUT_ELEMENT_DESC({ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }));
AddInputElement(new D3D11_INPUT_ELEMENT_DESC({ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }));
int indexCount = indices.Size();
int vertexCount = vertices.Size();
int vertexStride = sizeof(VertexPosColor);
Init(aEffect, indexCount, reinterpret_cast<char*>(&indices[0]), vertexCount
, vertexStride, reinterpret_cast<char*>(&vertices[0]), aGPUContext, aAssetContainer);
myIndexData = new IndexData();
myVertexData = new VertexData();
myIndexData->myNumberOfIndices = indexCount;
myVertexData->myNumberOfVertices = vertexCount;
myVertexData->myStride = vertexStride;
}
