void FSKDemodulation::generateDemodulation(
const std::vector<int> &BitesVector) {
multiBuffer1 = allocateBuffer(this->ttime, this->samplingFrequency);
multiBuffer2 = allocateBuffer(this->ttime, this->samplingFrequency);
demodulatedSignal = allocateBuffer(this->ttime, this->samplingFrequency);
binarySignal = allocateBuffer(this->ttime, this->samplingFrequency);
int bit = 0, tempBit = 0, i = 0, ii = 0, highFrequency = 0, lowFrequency = 0;
this->sumHighFrequency = 0;
this->sumLowFrequency = 0;
for (auto x : BitesVector) {
std::cout << i << ". bit's value: " << x << std::endl;
for (int j = 0; j < 100; j++) {
bit = (i * 100) + j;
multiBuffer2[bit] =
modulatedSignal[bit] * this->amplitude *
sin((6 * M_PI * (this->signalFrequency / 2) * bit) / 100);
multiBuffer1[bit] =
modulatedSignal[bit] * this->amplitude *
sin((2 * M_PI * (this->signalFrequency / 2) * bit) / 100);
this->sumHighFrequency += multiBuffer2[bit];
this->sumLowFrequency += multiBuffer1[bit];
demodulatedSignal[bit] = this->sumHighFrequency - this->sumLowFrequency;
}
this->sumHighFrequency = 0;
this->sumLowFrequency = 0;
++i;
}
i = 0;
for (int k = 0; k < BitesVector.size(); ++k) {
for (int j = 0; j < 100; j++) {
bit = (i * 100) + j;
if (demodulatedSignal[bit] > 0) {
++highFrequency;
} else {
++lowFrequency;
}
}
for (int j = 0; j < 100; j++) {
tempBit = (ii * 100) + j;
if (highFrequency > lowFrequency) {
binarySignal[tempBit] = 1;
} else {
binarySignal[tempBit] = 0;
}
}
highFrequency = 0;
lowFrequency = 0;
++i;
++ii;
}
binarySignal[tempBit - 1] = 1.2f;
}
void GLES2HardwarePixelBuffer::blitFromMemory(const PixelBox &src, const Image::Box &dstBox)
{
if (!mBuffer.contains(dstBox))
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"Destination box out of range",
"GLES2HardwarePixelBuffer::blitFromMemory");
}
PixelBox scaled;
if (src.getWidth() != dstBox.getWidth() ||
src.getHeight() != dstBox.getHeight() ||
src.getDepth() != dstBox.getDepth())
{
// Scale to destination size.
// This also does pixel format conversion if needed
allocateBuffer();
scaled = mBuffer.getSubVolume(dstBox);
Image::scale(src, scaled, Image::FILTER_BILINEAR);
}
#if OGRE_PLATFORM != OGRE_PLATFORM_APPLE_IOS
else if ((src.format != mFormat) ||
((GLES2PixelUtil::getGLOriginFormat(src.format) == 0) && (src.format != PF_R8G8B8)))
#else
else if (GLES2PixelUtil::getGLOriginFormat(src.format) == 0)
#endif
{
// Extents match, but format is not accepted as valid source format for GL
// do conversion in temporary buffer
allocateBuffer();
scaled = mBuffer.getSubVolume(dstBox);
PixelUtil::bulkPixelConversion(src, scaled);
}
else
{
allocateBuffer();
// No scaling or conversion needed
scaled = src;
if (src.format == PF_R8G8B8)
{
scaled.format = PF_B8G8R8;
PixelUtil::bulkPixelConversion(src, scaled);
}
#if OGRE_PLATFORM == OGRE_PLATFORM_NACL
if (src.format == PF_A8R8G8B8)
{
scaled.format = PF_A8B8G8R8;
PixelUtil::bulkPixelConversion(src, scaled);
}
#endif
}
upload(scaled, dstBox);
freeBuffer();
}
daeString daeStringTable::allocString(daeString string)
{
if ( string == NULL ) return _empty;
size_t stringSize = strlen(string) + 1;
size_t sizeLeft = _stringBufferSize - _stringBufferIndex;
daeString buf;
if (sizeLeft < stringSize)
{
if (stringSize > _stringBufferSize)
_stringBufferSize = ((stringSize / _stringBufferSize) + 1) * _stringBufferSize ;
buf = allocateBuffer();
}
else
{
buf = _stringBuffersList.get((daeInt)_stringBuffersList.getCount()-1);
}
daeChar *str = (char*)buf + _stringBufferIndex;
memcpy(str,string,stringSize);
_stringBufferIndex += stringSize;
int align = sizeof(void*);
_stringBufferIndex = (_stringBufferIndex+(align-1)) & (~(align-1));
return str;
}
void ReadBuffer::appendBuffer(const unsigned char *message, unsigned int length)
{
if (start_ + length_ + length > size_)
{
unsigned int newSize = length_ + length + initialReadSize_;
#ifdef TEST
*logofs << "ReadBuffer: WARNING! Resizing buffer "
<< "for FD#" << transport_ -> fd()
<< " from " << size_ << " to " << newSize
<< " bytes.\n" << logofs_flush;
#endif
unsigned char *newBuffer = allocateBuffer(newSize);
memcpy(newBuffer, buffer_ + start_, length_);
delete [] buffer_;
buffer_ = newBuffer;
size_ = newSize;
start_ = 0;
}
memcpy(buffer_ + start_ + length_, message, length);
length_ += length;
transport_ -> pendingReset();
owner_ = 1;
}
PixelBox GL3PlusHardwarePixelBuffer::lockImpl( const Image::Box &lockBox, LockOptions options )
{
//Allocate memory for the entire image, as the buffer
//maynot be freed and be reused in subsequent calls.
allocateBuffer( PixelUtil::getMemorySize( mWidth, mHeight, mDepth, mFormat ) );
mBuffer = PixelBox( lockBox.getWidth(), lockBox.getHeight(),
lockBox.getDepth(), mFormat, mBuffer.data );
mCurrentLock = mBuffer;
mCurrentLock.left = lockBox.left;
mCurrentLock.right += lockBox.left;
mCurrentLock.top = lockBox.top;
mCurrentLock.bottom += lockBox.top;
if(options != HardwareBuffer::HBL_DISCARD)
{
// Download the old contents of the texture
download( mCurrentLock );
}
mCurrentLockOptions = options;
mLockedBox = lockBox;
mCurrentLock = mBuffer;
return mBuffer;
}
void ArrayBase::load(std::istream &inStream) {
std::string tag;
size_t count;
NTA_CHECK(inStream.get() == '[')
<< "Binary load of Array, expected starting '['.";
inStream >> count;
inStream >> tag;
type_ = BasicType::parse(tag);
if (count > 0 && type_ == NTA_BasicType_SDR) {
SDR *sdr = new SDR();
sdr->load(inStream);
std::shared_ptr<char> sp((char *)(sdr));
buffer_ = sp;
count_ = sdr->size;
capacity_ = sdr->size;
} else {
allocateBuffer(count);
inStream.ignore(1);
inStream.read(buffer_.get(), capacity_);
}
NTA_CHECK(inStream.get() == ']')
<< "Binary load of Array, expected ending ']'.";
inStream.ignore(1); // skip over the endl
}
/** @brief Contruct a new string from an existing numeric value
@param const long value: The numeric value to create the string from
@param const int base: The base of the number system used to convert the value (2|8|10|16)
*/
String::String(const long value, const int base)
{
char buf[33];
sup_itoa(value, buf, base);
allocateBuffer(m_length = strlen(buf));
if (m_buffer != NULL)
strcpy(m_buffer, buf);
}
/** @brief Contruct a new string from an existing C string
@param const char* cstr: Pointer to existing C string to copy
*/
String::String(const char* cstr)
{
if (cstr == NULL)
cstr = "";
allocateBuffer(m_length = strlen(cstr));
if (m_buffer != NULL)
strcpy(m_buffer, cstr);
}
int LCALIFLayer::allocateBuffers() {
const size_t numNeurons = getNumNeuronsAllBatches();
//Allocate data to keep track of trace
int status = PV_SUCCESS;
if (status==PV_SUCCESS) status = allocateBuffer(&integratedSpikeCount, numNeurons, "integratedSpikeCount");
if (status==PV_SUCCESS) status = allocateBuffer(&Vadpt, numNeurons, "Vadpt");
if (status==PV_SUCCESS) status = allocateBuffer(&Vattained, numNeurons, "Vattained");
if (status==PV_SUCCESS) status = allocateBuffer(&Vmeminf, numNeurons, "Vmeminf");
if (status==PV_SUCCESS) status = allocateBuffer(&G_Norm, numNeurons, "G_Norm");
if (status==PV_SUCCESS) status = allocateBuffer(&GSynExcEffective, numNeurons, "GSynExcEffective");
if (status==PV_SUCCESS) status = allocateBuffer(&GSynInhEffective, numNeurons, "GSynInhEffective");
if (status==PV_SUCCESS) status = allocateBuffer(&excitatoryNoise, numNeurons, "excitatoryNoise");
if (status==PV_SUCCESS) status = allocateBuffer(&inhibitoryNoise, numNeurons, "inhibitoryNoise");
if (status==PV_SUCCESS) status = allocateBuffer(&inhibNoiseB, numNeurons, "inhibNoiseB");
if (status!=PV_SUCCESS) exit(EXIT_FAILURE);
return LIFGap::allocateBuffers();
}
AmBufferedAudio::AmBufferedAudio(size_t output_buffer_size,
size_t low_buffer_thresh, size_t full_buffer_thresh)
: output_buffer_size(output_buffer_size),
low_buffer_thresh(low_buffer_thresh), full_buffer_thresh(full_buffer_thresh),
r(0), w(0), eof(false), err_code(0)
{
allocateBuffer();
}
void SoundEmitter::play(const std::string &filename,
int volume,
int pitch)
{
float _volume = clamp<int>(volume, 0, 100) / 100.0f;
float _pitch = clamp<int>(pitch, 50, 150) / 100.0f;
SoundBuffer *buffer = allocateBuffer(filename);
if (!buffer)
return;
/* Try to find first free source */
size_t i;
for (i = 0; i < srcCount; ++i)
if (AL::Source::getState(alSrcs[srcPrio[i]]) != AL_PLAYING)
break;
/* If we didn't find any, try to find the lowest priority source
* with the same buffer to overtake */
if (i == srcCount)
for (size_t j = 0; j < srcCount; ++j)
if (atchBufs[srcPrio[j]] == buffer)
i = j;
/* If we didn't find any, overtake the one with lowest priority */
if (i == srcCount)
i = 0;
size_t srcIndex = srcPrio[i];
/* Only detach/reattach if it's actually a different buffer */
bool switchBuffer = (atchBufs[srcIndex] != buffer);
/* Push the used source to the back of the priority list */
arrayPushBack(srcPrio, srcCount, i);
AL::Source::ID src = alSrcs[srcIndex];
AL::Source::stop(src);
if (switchBuffer)
AL::Source::detachBuffer(src);
SoundBuffer *old = atchBufs[srcIndex];
if (old)
SoundBuffer::deref(old);
atchBufs[srcIndex] = SoundBuffer::ref(buffer);
if (switchBuffer)
AL::Source::attachBuffer(src, buffer->alBuffer);
AL::Source::setVolume(src, _volume * GLOBAL_VOLUME);
AL::Source::setPitch(src, _pitch);
AL::Source::play(src);
}
/** @brief Contruct a new string from an existing character
@param const unsigned char value: Character value to use for string data
*/
String::String(const unsigned char value)
{
m_length = 1;
allocateBuffer(1);
if (m_buffer != NULL) {
m_buffer[0] = value;
m_buffer[1] = 0;
}
}
void
Allocator::acquireMemory(void)
{
quota_ = quotaInitial_;
for (BufferCount i = 0; i < nInitial_; ++i)
{
reuseList_.push_back(allocateBuffer(true));
}
}
static DWIOBUFF *findWrBuffer( // FIND A BUFFER FOR WRITING
void )
{
DWIOBUFF *ctl; // - buffer control
ctl = allocateBuffer();
ctl->disk_addr = IoSuppTempNextBlock( DWBLOCK_FACTOR );
ctl->writing = true;
ctl->written = false;
return ctl;
}
void DsdSampleReader::clearBuffer()
{
if (!isBufferAllocated) {
allocateBuffer();
return;
}
dsf2flac_uint8 c = getIdleSample();
for (dsf2flac_uint32 i = 0; i<getNumChannels(); i++)
for (dsf2flac_uint32 j=0; j<getBufferLength(); j++)
circularBuffers[i].push_front(c);
}
PixelBox GL3PlusHardwarePixelBuffer::lockImpl(const Image::Box &lockBox, LockOptions options)
{
allocateBuffer();
if(options != HardwareBuffer::HBL_DISCARD)
{
// Download the old contents of the texture
download(mBuffer);
}
mCurrentLockOptions = options;
mLockedBox = lockBox;
return mBuffer.getSubVolume(lockBox);
}
OMX_ERRORTYPE SHM_PcmOut::instantiateBindingComponent(void) {
OMX_ERRORTYPE error;
OMX_U32 priority = getPortPriorityLevel();
MEMORY_TRACE_ENTER("SHM_PcmOut::instantiateBindingComponent");
if(priority == 0){
OstTraceFiltInst1(TRACE_ALWAYS, "AFM_PROXY: SHM_PcmOut:: instantiateBindingComponent: SHM_PcmOut instantiated with priority %d",priority +1);
error = ENS::instantiateNMFComponent(
getNMFDomainHandle(), "bindings.shmpcm.shmout",
"SHM_PcmOut", &mNmfHandle, priority+1);
}
else{
OstTraceFiltInst1(TRACE_ALWAYS, "AFM_PROXY: SHM_PcmOut:: instantiateBindingComponent: SHM_PcmOut instantiated with priority %d",priority);
error = ENS::instantiateNMFComponent(
getNMFDomainHandle(), "bindings.shmpcm.shmout",
"SHM_PcmOut", &mNmfHandle, priority);
}
if (error != OMX_ErrorNone) return error;
error = ENS::bindComponent(
mNmfHandle, "osttrace", mOstTrace, "osttrace");
if (error != OMX_ErrorNone) return error;
OstTraceFiltInst1(TRACE_ALWAYS, "AFM_PROXY: SHM_PcmOut:: instantiateBindingComponent: synchronisation instantiated with priority %d",priority);
error = ENS::instantiateNMFComponent(
getNMFDomainHandle(), "misc.synchronisation", "synchronisation",
&mNmfSyncLib, priority);
if (error != OMX_ErrorNone) return error;
error = ENS::bindComponent(
mNmfHandle, "synchronisation", mNmfSyncLib, "synchronisation");
if (error != OMX_ErrorNone) return error;
error = ENS::bindComponentFromHostEx(mNmfHandle, "configure", &mIconfigure, 1);
if (error != OMX_ErrorNone) return error;
error = ENS::bindComponent(
mNmfHandle, "outputport", mNmfSharedBuffer, "emptythisbuffer");
if (error != OMX_ErrorNone) return error;
error = ENS::bindComponent(
mNmfSharedBuffer, "mpc", mNmfHandle, "fillthisbuffer");
if (error != OMX_ErrorNone) return error;
error = allocateBuffer();
if (error != OMX_ErrorNone) return error;
MEMORY_TRACE_LEAVE("SHM_PcmOut::instantiateBindingComponent");
return OMX_ErrorNone;
}
int OffscreenNativeWindow::setBufferCount(int count)
{
TRACE("%s: count=%i", __PRETTY_FUNCTION__, count);
if (m_buffers.size() < count) {
for (int n = 0; n < m_buffers.size() - count; n++) {
OffscreenNativeWindowBuffer *buffer = allocateBuffer();
m_buffers.push_back(buffer);
}
}
return NO_ERROR;
}
char*
Allocator::allocate(bool failureIsFatal)
{
// Return NULL if Allocator memory has been released
if (!memAllocated_ && (reuseList_.size() == 0))
{
return NULL;
}
else
{
return allocateBuffer(failureIsFatal);
}
}
void GL3PlusHardwarePixelBuffer::blitFromMemory(const PixelBox &src, const Image::Box &dstBox)
{
if (!mBuffer.contains(dstBox))
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"Destination box out of range",
"GL3PlusHardwarePixelBuffer::blitFromMemory");
}
PixelBox scaled;
if (src.getWidth() != dstBox.getWidth() ||
src.getHeight() != dstBox.getHeight() ||
src.getDepth() != dstBox.getDepth())
{
// Scale to destination size.
// This also does pixel format conversion if needed.
allocateBuffer( mSizeInBytes );
scaled = mBuffer.getSubVolume(dstBox);
Image::scale(src, scaled, Image::FILTER_BILINEAR);
}
else if (GL3PlusPixelUtil::getGLOriginFormat(src.format) == 0)
{
// Extents match, but format is not accepted as valid
// source format for GL. Do conversion in temporary buffer.
allocateBuffer( mSizeInBytes );
scaled = mBuffer.getSubVolume(dstBox);
PixelUtil::bulkPixelConversion(src, scaled);
}
else
{
allocateBuffer( mSizeInBytes );
// No scaling or conversion needed.
scaled = src;
}
upload(scaled, dstBox);
freeBuffer();
}
void ASKDemodulation::generateDemodulation(
const std::vector<int> &BitesVector) {
multiBuffer = allocateBuffer(this->ttime, this->samplingFrequency);
demodulatedSignal = allocateBuffer(this->ttime, this->samplingFrequency);
binarySignal = allocateBuffer(this->ttime, this->samplingFrequency);
int bit = 0;
int i = 0;
this->sum = 0;
for (auto x : BitesVector) {
std::cout << i << ". bit's value: " << x << std::endl;
for (int j = 0; j < 100; j++) {
bit = (i * 100) + j;
multiBuffer[bit] =
modulatedSignal[bit] * this->amplitude *
sin((2 * M_PI * (this->signalFrequency / 2) * bit) / 100);
this->sum += multiBuffer[bit];
demodulatedSignal[bit] = this->sum;
}
this->sum = 0;
++i;
}
i = 0;
for (int k = 0; k < BitesVector.size(); ++k) {
for (int j = 0; j < 100; j++) {
bit = (i * 100) + j;
if (demodulatedSignal[bit] > 0) {
binarySignal[bit] = 1.0f;
} else {
binarySignal[bit] = 0.0f;
}
}
++i;
}
binarySignal[bit - 1] = 1.2f;
}
void SinusDrawing::generateSinusSignal(float SignalFrequency, float Amplitude,
float StartPoint) {
buffer = nullptr;
buffer = allocateBuffer(ttime, samplingFrequency);
amplitude = Amplitude;
startPoint = StartPoint;
signalFrequency = SignalFrequency;
for (int i = 0; i < samplingFrequency * ttime; i++) {
buffer[i] =
amplitude *
sin(2 * M_PI * signalFrequency * (i / samplingFrequency) + startPoint);
}
}
int IncrementLayer::allocateDataStructures() {
int status = ANNLayer::allocateDataStructures();
if (status == PV_SUCCESS) status = allocateBuffer(&Vprev, getNumNeurons(), "V at previous time");
if (status == PV_SUCCESS) {
assert(GSyn && GSyn[0] && GSyn[1]);
for( int k=0; k<getNumNeurons(); k++ ) {
assert(GSyn[0][k]==0 && GSyn[1][k]==0);
}
}
if (status != PV_SUCCESS) exit(EXIT_FAILURE);
return status;
}
PixelBox GLES2HardwarePixelBuffer::lockImpl(const Image::Box lockBox, LockOptions options)
{
allocateBuffer();
if (options != HardwareBuffer::HBL_DISCARD
//#ifndef GL_NV_read_buffer
&& (mUsage & HardwareBuffer::HBU_WRITE_ONLY) == 0)
{
// Download the old contents of the texture
download(mBuffer);
}
mCurrentLockOptions = options;
mLockedBox = lockBox;
return mBuffer.getSubVolume(lockBox);
}
PixelData GLPixelBuffer::lockImpl(PixelVolume lockBox, GpuLockOptions options)
{
allocateBuffer();
if(options != GBL_WRITE_ONLY_DISCARD)
{
// Download the old contents of the texture
download(mBuffer);
}
mCurrentLockOptions = options;
mLockedBox = lockBox;
return mBuffer.getSubVolume(lockBox);
}
bool DsdSampleReader::setBufferLength(dsf2flac_uint32 b)
{
if (b<1) {
errorMsg = "dsdSampleReader::setBufferLength:buffer length must be >0";
return false;
}
bufferLength=b;
if (!isBufferAllocated)
allocateBuffer();
for (dsf2flac_uint32 i = 0; i<getNumChannels(); i++)
circularBuffers[i].set_capacity(getBufferLength());
clearBuffer(); // should be called by rewind... but just incase.
rewind();
return true;
}
int OffscreenNativeWindow::dequeueBuffer(BaseNativeWindowBuffer **buffer, int *fenceFd)
{
TRACE("%s", __PRETTY_FUNCTION__);
OffscreenNativeWindowBuffer *selectedBuffer = 0;
std::list<OffscreenNativeWindowBuffer*>::iterator iter;
g_mutex_lock(&m_bufferMutex);
while (1) {
for (iter = m_buffers.begin(); iter != m_buffers.end(); iter++) {
OffscreenNativeWindowBuffer *currentBuffer = *iter;
if (!currentBuffer->busy()) {
TRACE("%s: Found buffer ready to be used", __PRETTY_FUNCTION__);
selectedBuffer = currentBuffer;
break;
}
}
if (selectedBuffer)
break;
TRACE("%s: Waiting for buffer to be released", __PRETTY_FUNCTION__);
g_cond_wait(&m_nextBufferCondition, &m_bufferMutex);
TRACE("%s: Got notified that we have a new buffer available", __PRETTY_FUNCTION__);
}
// check wether buffer already has the right size
if (selectedBuffer->width != m_width || selectedBuffer->height != m_height) {
TRACE("%s buffer and window size doesn't match: recreating buffer ...\n", __PRETTY_FUNCTION__);
m_buffers.remove(selectedBuffer);
// Let the current buffer be cleared up by it's own
selectedBuffer->decStrong(0);
selectedBuffer = allocateBuffer();
m_buffers.push_back(selectedBuffer);
}
selectedBuffer->setBusy(true);
g_mutex_unlock(&m_bufferMutex);
*buffer = selectedBuffer;
return NO_ERROR;
}
int PursuitLayer::allocateDataStructures() {
int status = ANNLayer::allocateDataStructures();
if (status == PV_SUCCESS) {
status = allocateBuffer(&wnormsq, getLayerLoc()->nf, "wnormsq");
}
if (status==PV_SUCCESS) {
status = allocateBuffer(&minimumLocations, getNumNeurons(), "minimumLocations");
}
if (status==PV_SUCCESS) {
status = allocateBuffer(&energyDrops, getNumNeurons(), "energyDrops");
}
int xy = getLayerLoc()->nx * getLayerLoc()->ny;
if (status==PV_SUCCESS) {
status = allocateBuffer(&minFeatures, xy, "minFeatures");
}
if (status==PV_SUCCESS) {
status = allocateBuffer(&energyDropsBestFeature, xy, "energyDropsBestFeature");
}
if (status==PV_SUCCESS) {
status = allocateBuffer(&foundFeatures, xy, "foundFeatures");
for (int k=0; k<xy; k++) {
foundFeatures[k]=-1;
}
}
if (status==PV_SUCCESS) {
status = allocateBuffer(&minLocationsBestFeature, xy, "minLocationsBestFeature");
}
if (status==PV_SUCCESS) {
status = allocateBuffer(&gSynSparse, xy, "gSynSparse");
}
if (status==PV_SUCCESS) {
status = allocateBuffer(&minEnergyFiltered, xy, "minEnergyFiltered");
}
if (status != PV_SUCCESS) abort();
return status;
}
// WARNING: do not call this while device is in use! buffer is not locked!
void AmBufferedAudio::setBufferSize(size_t _output_buffer_size,
size_t _low_buffer_thresh,
size_t _full_buffer_thresh) {
DBG("set output buffer size to %zd low thresh %zd, fill thresh %zd\n",
_output_buffer_size, _low_buffer_thresh, _full_buffer_thresh);
bool reset_buffer = output_buffer_size != _output_buffer_size;
output_buffer_size = _output_buffer_size;
low_buffer_thresh = _low_buffer_thresh;
full_buffer_thresh = _full_buffer_thresh;
if (reset_buffer) {
releaseBuffer();
allocateBuffer();
}
}
bool VertexBuffer::allocate(ID3D11Device* device, void* vertices, UINT stride, UINT numVertices,D3D11_USAGE usage, UINT cpuAccess ,
bool createSOBuffer)
{
m_stride = 0;
m_vertexCount = 0;
UINT binding = createSOBuffer ? D3D11_BIND_STREAM_OUTPUT : D3D11_BIND_VERTEX_BUFFER;
bool res = allocateBuffer(device, vertices, stride*numVertices, binding, usage, cpuAccess);
if (res){
m_vertexCount = numVertices;
m_stride = stride;
return true;
}
return false;
}
