/*
Now for the overloaded Draw function. It's a little bit messy, as we have to copy all of the
Particle data structs into one contiguous lump of memory to send using the OpenGL command
glBufferSubData - which you should remember from the skeletal animation tutorial.
Why don't we use glMapBuffer? Just uploading a whole load of new data is probably easier
and quicker than faffing with mapping and unmapping buffers!
*/
void ParticleEmitter::Draw() {
ResizeArrays();
//Get 2 contiguous sections of memory full of our particle info
for(unsigned int i = 0; i < particles.size(); ++i) {
vertices[i] = particles.at(i)->position;
colours[i] = particles.at(i)->colour;
}
glBindVertexArray(arrayObject);
//Bind our vertex data, and update its data with that of the vertices array
glBindBuffer(GL_ARRAY_BUFFER, bufferObject[VERTEX_BUFFER]);
glBufferSubData(GL_ARRAY_BUFFER, 0, particles.size()*sizeof(Vector3), (void*)vertices);
glVertexAttribPointer(VERTEX_BUFFER, 3, GL_FLOAT, GL_FALSE, sizeof(Vector3), 0); //Tell the VAO we have positions...
glEnableVertexAttribArray(VERTEX_BUFFER); //Binds this buffer to the VAO
//And now do the same for colours...
glBindBuffer(GL_ARRAY_BUFFER, bufferObject[COLOUR_BUFFER]);
glBufferSubData(GL_ARRAY_BUFFER, 0, particles.size()*sizeof(Vector4), (void*)colours);
glVertexAttribPointer(COLOUR_BUFFER, 4, GL_FLOAT, GL_FALSE, sizeof(Vector4), 0);
glEnableVertexAttribArray(COLOUR_BUFFER);
//We're going to use a type of alpha blending known as additive blending here. Overlapping
//particles will have their colours added together on screen, giving us a cool effect when
//particles are near each other. Fire a lot of particles at once with slow speed to get a
//'plasma ball' type effect!
//glEnable(GL_BLEND);
//glBlendFunc(GL_SRC_ALPHA,GL_ONE);
//No were not
//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//And now do our usual Drawing stuff...
glActiveTexture(GL_TEXTURE0);
if(texture)
glBindTexture(GL_TEXTURE_2D, texture);
glDrawArrays(GL_POINTS, 0, particles.size()); // draw ordered list of vertices
glBindTexture(GL_TEXTURE_2D, 0);
glBindVertexArray(0); //Remember to turn off our VAO ;)
};
/*
Every frame, we're going to call this Update function. In a 'real' game, this maybe wouldn't
be the Renderer's job, but maybe part of the gameplay 'entity' system. Depends on what
the game components can 'see' (i.e are we hiding what type of API we're using for rendering
from the rest of the game, etc).
It goes through every particle of this emitter, and updates it. if it has no 'life' left,
it is removed from the particle list. If it's time to generate some new particles, we do
that in here, too. Finally, this function resizes our VBOs if necessary.
*/
void ParticleEmitter::Update(float msec) {
nextParticleTime -= msec; //some time has passed!
/*
Enough time might have passed that more than 1 'launch' of particles is necessary...
*/
while(nextParticleTime <= 0) {
nextParticleTime += particleRate;
//Add a number of particles to the vector, obtained from the free list.
for(int i = 0; i < numLaunchParticles; ++i) {
particles.push_back(GetFreeParticle());
}
}
//Now for the particle 'think' function. Particles are so 'lightweight' there's not
//much point putting this as a member variable of the Particle struct...
for(std::vector<Particle *>::iterator i = particles.begin(); i != particles.end();/*No I++ here!!! */) {
Particle *p = (*i);
//We're keeping the particles 'life' in the alpha channel of its colour.
//This means it'll also fade out as it loses energy. Kinda cool?
p->colour.w -= (msec / particleLifetime);
//If this particle has ran out of life, remove it from the 'active' list,
//and put it on the 'free' list for reuse later.
if(p->colour.w <= 0.0f) {
freeList.push_back(p);
i = particles.erase(i);
}
else{
//Otherwise, this particle must be still 'alive'. Update its
//position by multiplying its normalised direction by the
//particle speed, and adding the result to the position. Easy!
p->position += p->direction*(msec*particleSpeed);
++i; //Only update our iterator value here.
//If we didn't do this, we'd skip over particles when removing
//particles from the list...
}
}
//If we now have more particles than we have graphics memory for, we
//must allocate some new space for them, using ResizeArrays.
if(particles.size() > largestSize) {
ResizeArrays();
}
}
void CRouteFinder::FindRoute(const vector::BinaryInt &inputArray)
{
ResizeArrays();
m_valueArray[1][1] = inputArray[1][1];
m_strArray[1][1] = "1 1";
int max;
std::string routeStr;
for (size_t stepsCounter = 1; stepsCounter <= m_arrayOptions.stepsCount; ++stepsCounter)
{
for (size_t i = 1; i <= m_arrayOptions.squareMatrixDimension; ++i)
{
for (size_t j = 1; j <= m_arrayOptions.squareMatrixDimension; ++j)
{
if (((i + j) % 2) != (stepsCounter % 2))
{
max = 0;
routeStr = "";
if (CellParamethersIsCorrect(i, m_arrayOptions.squareMatrixDimension, m_valueArray[i + 1][j] > max, max))
{
SetNewCellParamethers(max, routeStr, i + 1, j);
}
if (CellParamethersIsCorrect(1, i, m_valueArray[i - 1][j], max))
{
SetNewCellParamethers(max, routeStr, i - 1, j);
}
if (CellParamethersIsCorrect(1, j, m_valueArray[i][j - 1], max))
{
SetNewCellParamethers(max, routeStr, i, j - 1);
}
if (CellParamethersIsCorrect(j, m_arrayOptions.squareMatrixDimension, m_valueArray[i][j + 1], max))
{
SetNewCellParamethers(max, routeStr, i, j + 1);
}
if (max != 0)
{
m_valueArray[i][j] = max + inputArray[i][j];
m_strArray[i][j] = routeStr + "\n" + std::to_string(i) + " " + std::to_string(j);
}
}
}
}
}
}
size_t SparseBinaryInput<ElemType>::ReadMinibatch(void* data_buffer, std::map<std::wstring, shared_ptr<BinaryMatrix<ElemType>>>& matrices)
{
// fprintf(stderr, "start read minibatch.\n");
/*
size_t readSize = m_offsets[cur_batch + 1] - m_offsets[cur_batch];
void* data_buffer = GetTempDataPointer(readSize);
fprintf(stderr, "start reading data.\n");
m_inFile.clear();
m_inFile.seekg(m_dataStart + m_offsets[cur_batch], ios::beg);
m_inFile.read((char*)data_buffer, readSize);
fprintf(stderr, "done reading data.\n");
*/
int32_t nnz;
int32_t curMBSize;
int64_t buffer_offset = 0;
curMBSize = *(int32_t*) ((char*) data_buffer + buffer_offset);
buffer_offset += sizeof(int32_t);
for (int32_t c = 0; c < m_features.size(); c++)
{
// fprintf(stderr, "read features %d.\n", c);
nnz = *(int32_t*) ((char*) data_buffer + buffer_offset);
buffer_offset += sizeof(int32_t);
ElemType* vals = (ElemType*) ((char*) data_buffer + buffer_offset);
buffer_offset += sizeof(ElemType) * nnz;
int32_t* rowIndices = (int32_t*) ((char*) data_buffer + buffer_offset);
buffer_offset += sizeof(int32_t) * nnz;
int32_t* colIndices = (int32_t*) ((char*) data_buffer + buffer_offset);
buffer_offset += sizeof(int32_t) * (curMBSize + 1);
auto findMat = matrices.find(m_features[c]);
if (findMat != matrices.end())
{
auto mat = findMat->second;
mat->ResizeArrays(nnz);
mat->AddValues(vals, nnz);
mat->AddRowIndices(rowIndices, nnz);
mat->AddColIndices(colIndices, curMBSize + 1);
mat->UpdateNNz(nnz);
#ifdef DEBUG
mat->Print("features");
#endif
}
}
for (int32_t c = 0; c < m_labels.size(); c++)
{
// fprintf(stderr, "read labels %d.\n", c);
int32_t numCols = m_mappedNumCols[m_labels[c]];
ElemType* vals = (ElemType*) ((char*) data_buffer + buffer_offset);
buffer_offset += sizeof(ElemType) * curMBSize * numCols;
auto findMat = matrices.find(m_labels[c]);
if (findMat != matrices.end())
{
auto mat = findMat->second;
mat->AddValues(vals, curMBSize);
#ifdef DEBUG
mat->Print("labels");
#endif
}
}
return (size_t) curMBSize;
}
