bool GrGLVertexBuffer::updateData(const void* src, size_t srcSizeInBytes) { GrAssert(fBufferID); GrAssert(!isLocked()); if (srcSizeInBytes > this->sizeInBytes()) { return false; } this->bind(); GrGLenum usage = dynamic() ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW; #if !GR_GL_USE_BUFFER_DATA_NULL_HINT // Note that we're cheating on the size here. Currently no methods // allow a partial update that preserves contents of non-updated // portions of the buffer (and lock() does a glBufferData(..size, NULL..)) GL_CALL(BufferData(GR_GL_ARRAY_BUFFER, srcSizeInBytes, src, usage)); #else if (this->sizeInBytes() == srcSizeInBytes) { GL_CALL(BufferData(GR_GL_ARRAY_BUFFER, srcSizeInBytes, src, usage)); } else { // Before we call glBufferSubData we give the driver a hint using // glBufferData with NULL. This makes the old buffer contents // inaccessible to future draws. The GPU may still be processing draws // that reference the old contents. With this hint it can assign a // different allocation for the new contents to avoid flushing the gpu // past draws consuming the old contents. GL_CALL(BufferData(GR_GL_ARRAY_BUFFER, this->sizeInBytes(), NULL, usage)); GL_CALL(BufferSubData(GR_GL_ARRAY_BUFFER, 0, srcSizeInBytes, src)); } #endif return true; }
void CSave::BufferString( char *pdata, int len ) { char c = 0; BufferData( pdata, len ); // Write the string BufferData( &c, 1 ); // Write a null terminator }
void GrGLBuffer::onMap() { if (this->wasDestroyed()) { return; } VALIDATE(); SkASSERT(!this->isMapped()); if (0 == fBufferID) { fMapPtr = fCPUData; VALIDATE(); return; } // TODO: Make this a function parameter. bool readOnly = (kXferGpuToCpu_GrBufferType == fIntendedType); // Handling dirty context is done in the bindBuffer call switch (this->glCaps().mapBufferType()) { case GrGLCaps::kNone_MapBufferType: break; case GrGLCaps::kMapBuffer_MapBufferType: { GrGLenum target = this->glGpu()->bindBuffer(fIntendedType, this); // Let driver know it can discard the old data if (GR_GL_USE_BUFFER_DATA_NULL_HINT || fGLSizeInBytes != fSizeInBytes) { GL_CALL(BufferData(target, fSizeInBytes, nullptr, fUsage)); } GL_CALL_RET(fMapPtr, MapBuffer(target, readOnly ? GR_GL_READ_ONLY : GR_GL_WRITE_ONLY)); break; } case GrGLCaps::kMapBufferRange_MapBufferType: { GrGLenum target = this->glGpu()->bindBuffer(fIntendedType, this); // Make sure the GL buffer size agrees with fDesc before mapping. if (fGLSizeInBytes != fSizeInBytes) { GL_CALL(BufferData(target, fSizeInBytes, nullptr, fUsage)); } GrGLbitfield writeAccess = GR_GL_MAP_WRITE_BIT; if (kXferCpuToGpu_GrBufferType != fIntendedType) { // TODO: Make this a function parameter. writeAccess |= GR_GL_MAP_INVALIDATE_BUFFER_BIT; } GL_CALL_RET(fMapPtr, MapBufferRange(target, 0, fSizeInBytes, readOnly ? GR_GL_MAP_READ_BIT : writeAccess)); break; } case GrGLCaps::kChromium_MapBufferType: { GrGLenum target = this->glGpu()->bindBuffer(fIntendedType, this); // Make sure the GL buffer size agrees with fDesc before mapping. if (fGLSizeInBytes != fSizeInBytes) { GL_CALL(BufferData(target, fSizeInBytes, nullptr, fUsage)); } GL_CALL_RET(fMapPtr, MapBufferSubData(target, 0, fSizeInBytes, readOnly ? GR_GL_READ_ONLY : GR_GL_WRITE_ONLY)); break; } } fGLSizeInBytes = fSizeInBytes; VALIDATE(); }
void CSave::BufferHeader( const char *pname, int size ) { short hashvalue = TokenHash( pname ); if( size > 1 << ( sizeof( short ) * 8 ) ) ALERT( at_error, "CSave :: BufferHeader() size parameter exceeds 'short'!" ); BufferData( ( const char * ) &size, sizeof( short ) ); BufferData( ( const char * ) &hashvalue, sizeof( short ) ); }
void GrGLBuffer::onMap() { SkASSERT(fBufferID); SkASSERT(!this->wasDestroyed()); VALIDATE(); SkASSERT(!this->isMapped()); // TODO: Make this a function parameter. bool readOnly = (GrGpuBufferType::kXferGpuToCpu == fIntendedType); // Handling dirty context is done in the bindBuffer call switch (this->glCaps().mapBufferType()) { case GrGLCaps::kNone_MapBufferType: return; case GrGLCaps::kMapBuffer_MapBufferType: { GrGLenum target = this->glGpu()->bindBuffer(fIntendedType, this); if (!readOnly) { // Let driver know it can discard the old data if (this->glCaps().useBufferDataNullHint() || fGLSizeInBytes != this->size()) { GL_CALL(BufferData(target, this->size(), nullptr, fUsage)); } } GL_CALL_RET(fMapPtr, MapBuffer(target, readOnly ? GR_GL_READ_ONLY : GR_GL_WRITE_ONLY)); break; } case GrGLCaps::kMapBufferRange_MapBufferType: { GrGLenum target = this->glGpu()->bindBuffer(fIntendedType, this); // Make sure the GL buffer size agrees with fDesc before mapping. if (fGLSizeInBytes != this->size()) { GL_CALL(BufferData(target, this->size(), nullptr, fUsage)); } GrGLbitfield access; if (readOnly) { access = GR_GL_MAP_READ_BIT; } else { access = GR_GL_MAP_WRITE_BIT; if (GrGpuBufferType::kXferCpuToGpu != fIntendedType) { // TODO: Make this a function parameter. access |= GR_GL_MAP_INVALIDATE_BUFFER_BIT; } } GL_CALL_RET(fMapPtr, MapBufferRange(target, 0, this->size(), access)); break; } case GrGLCaps::kChromium_MapBufferType: { GrGLenum target = this->glGpu()->bindBuffer(fIntendedType, this); // Make sure the GL buffer size agrees with fDesc before mapping. if (fGLSizeInBytes != this->size()) { GL_CALL(BufferData(target, this->size(), nullptr, fUsage)); } GL_CALL_RET(fMapPtr, MapBufferSubData(target, 0, this->size(), readOnly ? GR_GL_READ_ONLY : GR_GL_WRITE_ONLY)); break; } } fGLSizeInBytes = this->size(); VALIDATE(); }
Rlist *RlistFromSplitRegex(const char *string, const char *regex, size_t max_entries, bool allow_blanks) { assert(string); if (!string) { return NULL; } const char *sp = string; size_t entry_count = 0; int start = 0; int end = 0; Rlist *result = NULL; Buffer *buffer = BufferNewWithCapacity(CF_MAXVARSIZE); pcre *rx = CompileRegex(regex); if (rx) { while ((entry_count < max_entries) && StringMatchWithPrecompiledRegex(rx, sp, &start, &end)) { if (end == 0) { break; } BufferClear(buffer); BufferAppend(buffer, sp, start); if (allow_blanks || BufferSize(buffer) > 0) { RlistAppendScalar(&result, BufferData(buffer)); entry_count++; } sp += end; } pcre_free(rx); } if (entry_count < max_entries) { BufferClear(buffer); size_t remaining = strlen(sp); BufferAppend(buffer, sp, remaining); if ((allow_blanks && sp != string) || BufferSize(buffer) > 0) { RlistAppendScalar(&result, BufferData(buffer)); } } BufferDestroy(buffer); return result; }
void* GrGLBufferImpl::map(GrGpuGL* gpu) { VALIDATE(); SkASSERT(!this->isMapped()); if (0 == fDesc.fID) { fMapPtr = fCPUData; } else { switch (gpu->glCaps().mapBufferType()) { case GrGLCaps::kNone_MapBufferType: VALIDATE(); return NULL; case GrGLCaps::kMapBuffer_MapBufferType: this->bind(gpu); // Let driver know it can discard the old data if (GR_GL_USE_BUFFER_DATA_NULL_HINT || fDesc.fSizeInBytes != fGLSizeInBytes) { fGLSizeInBytes = fDesc.fSizeInBytes; GL_CALL(gpu, BufferData(fBufferType, fGLSizeInBytes, NULL, fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW)); } GR_GL_CALL_RET(gpu->glInterface(), fMapPtr, MapBuffer(fBufferType, GR_GL_WRITE_ONLY)); break; case GrGLCaps::kMapBufferRange_MapBufferType: { this->bind(gpu); // Make sure the GL buffer size agrees with fDesc before mapping. if (fDesc.fSizeInBytes != fGLSizeInBytes) { fGLSizeInBytes = fDesc.fSizeInBytes; GL_CALL(gpu, BufferData(fBufferType, fGLSizeInBytes, NULL, fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW)); } static const GrGLbitfield kAccess = GR_GL_MAP_INVALIDATE_BUFFER_BIT | GR_GL_MAP_WRITE_BIT; GR_GL_CALL_RET(gpu->glInterface(), fMapPtr, MapBufferRange(fBufferType, 0, fGLSizeInBytes, kAccess)); break; } case GrGLCaps::kChromium_MapBufferType: this->bind(gpu); // Make sure the GL buffer size agrees with fDesc before mapping. if (fDesc.fSizeInBytes != fGLSizeInBytes) { fGLSizeInBytes = fDesc.fSizeInBytes; GL_CALL(gpu, BufferData(fBufferType, fGLSizeInBytes, NULL, fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW)); } GR_GL_CALL_RET(gpu->glInterface(), fMapPtr, MapBufferSubData(fBufferType, 0, fGLSizeInBytes, GR_GL_WRITE_ONLY)); break; } } VALIDATE(); return fMapPtr; }
Handle<Value> MerlinImage::New(const Arguments& args) { HandleScope scope; size_t len = BufferLength(args[0]->ToObject()); node::Buffer *tmp = node::Buffer::New(len); memcpy(BufferData(tmp), BufferData(args[0]->ToObject()), len); MerlinImage* img = new MerlinImage(tmp); img->Wrap(args.This()); return scope.Close(args.This()); }
bool GrGLBufferImpl::updateData(GrGpuGL* gpu, const void* src, size_t srcSizeInBytes) { SkASSERT(!this->isMapped()); VALIDATE(); if (srcSizeInBytes > fDesc.fSizeInBytes) { return false; } if (0 == fDesc.fID) { memcpy(fCPUData, src, srcSizeInBytes); return true; } this->bind(gpu); GrGLenum usage = fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW; #if GR_GL_USE_BUFFER_DATA_NULL_HINT if (fDesc.fSizeInBytes == srcSizeInBytes) { GL_CALL(gpu, BufferData(fBufferType, (GrGLsizeiptr) srcSizeInBytes, src, usage)); } else { // Before we call glBufferSubData we give the driver a hint using // glBufferData with NULL. This makes the old buffer contents // inaccessible to future draws. The GPU may still be processing // draws that reference the old contents. With this hint it can // assign a different allocation for the new contents to avoid // flushing the gpu past draws consuming the old contents. fGLSizeInBytes = fDesc.fSizeInBytes; GL_CALL(gpu, BufferData(fBufferType, fGLSizeInBytes, NULL, usage)); GL_CALL(gpu, BufferSubData(fBufferType, 0, (GrGLsizeiptr) srcSizeInBytes, src)); } #else // Note that we're cheating on the size here. Currently no methods // allow a partial update that preserves contents of non-updated // portions of the buffer (map() does a glBufferData(..size, NULL..)) bool doSubData = false; #if GR_GL_MAC_BUFFER_OBJECT_PERFOMANCE_WORKAROUND static int N = 0; // 128 was chosen experimentally. At 256 a slight hitchiness was noticed // when dragging a Chromium window around with a canvas tab backgrounded. doSubData = 0 == (N % 128); ++N; #endif if (doSubData) { // The workaround is to do a glBufferData followed by glBufferSubData. // Chromium's command buffer may turn a glBufferSubData where the size // exactly matches the buffer size into a glBufferData. So we tack 1 // extra byte onto the glBufferData. fGLSizeInBytes = srcSizeInBytes + 1; GL_CALL(gpu, BufferData(fBufferType, fGLSizeInBytes, NULL, usage)); GL_CALL(gpu, BufferSubData(fBufferType, 0, srcSizeInBytes, src)); } else { fGLSizeInBytes = srcSizeInBytes; GL_CALL(gpu, BufferData(fBufferType, fGLSizeInBytes, src, usage)); } #endif return true; }
bool GrGLVertexBuffer::updateData(const void* src, size_t srcSizeInBytes) { GrAssert(fBufferID); GrAssert(!isLocked()); if (srcSizeInBytes > this->sizeInBytes()) { return false; } this->bind(); GrGLenum usage = dynamic() ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW; #if GR_GL_USE_BUFFER_DATA_NULL_HINT if (this->sizeInBytes() == srcSizeInBytes) { GL_CALL(BufferData(GR_GL_ARRAY_BUFFER, srcSizeInBytes, src, usage)); } else { // Before we call glBufferSubData we give the driver a hint using // glBufferData with NULL. This makes the old buffer contents // inaccessible to future draws. The GPU may still be processing // draws that reference the old contents. With this hint it can // assign a different allocation for the new contents to avoid // flushing the gpu past draws consuming the old contents. GL_CALL(BufferData(GR_GL_ARRAY_BUFFER, this->sizeInBytes(), NULL, usage)); GL_CALL(BufferSubData(GR_GL_ARRAY_BUFFER, 0, srcSizeInBytes, src)); } #else // Note that we're cheating on the size here. Currently no methods // allow a partial update that preserves contents of non-updated // portions of the buffer (lock() does a glBufferData(..size, NULL..)) bool doSubData = false; #if GR_GL_MAC_BUFFER_OBJECT_PERFOMANCE_WORKAROUND static int N = 0; // 128 was chosen experimentally. At 256 a slight hitchiness was noticed // when dragging a Chromium window around with a canvas tab backgrounded. doSubData = 0 == (N % 128); ++N; #endif if (doSubData) { // The workaround is to do a glBufferData followed by glBufferSubData. // Chromium's command buffer may turn a glBufferSubData where the size // exactly matches the buffer size into a glBufferData. So we tack 1 // extra byte onto the glBufferData. GL_CALL(BufferData(GR_GL_ARRAY_BUFFER, srcSizeInBytes + 1, NULL, usage)); GL_CALL(BufferSubData(GR_GL_ARRAY_BUFFER, 0, srcSizeInBytes, src)); } else { GL_CALL(BufferData(GR_GL_ARRAY_BUFFER, srcSizeInBytes, src, usage)); } #endif return true; }
static VersionCmpResult RunCmpCommand(EvalContext *ctx, const char *command, const char *v1, const char *v2, Attributes a, const Promise *pp, PromiseResult *result) { Buffer *expanded_command = BufferNew(); { VarRef *ref_v1 = VarRefParseFromScope("v1", PACKAGES_CONTEXT); EvalContextVariablePut(ctx, ref_v1, v1, CF_DATA_TYPE_STRING, "source=promise"); VarRef *ref_v2 = VarRefParseFromScope("v2", PACKAGES_CONTEXT); EvalContextVariablePut(ctx, ref_v2, v2, CF_DATA_TYPE_STRING, "source=promise"); ExpandScalar(ctx, NULL, PACKAGES_CONTEXT, command, expanded_command); EvalContextVariableRemove(ctx, ref_v1); VarRefDestroy(ref_v1); EvalContextVariableRemove(ctx, ref_v2); VarRefDestroy(ref_v2); } FILE *pfp = a.packages.package_commands_useshell ? cf_popen_sh(BufferData(expanded_command), "w") : cf_popen(BufferData(expanded_command), "w", true); if (pfp == NULL) { cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Can not start package version comparison command '%s'. (cf_popen: %s)", BufferData(expanded_command), GetErrorStr()); *result = PromiseResultUpdate(*result, PROMISE_RESULT_FAIL); BufferDestroy(expanded_command); return VERCMP_ERROR; } Log(LOG_LEVEL_VERBOSE, "Executing '%s'", BufferData(expanded_command)); int retcode = cf_pclose(pfp); if (retcode == -1) { cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Error during package version comparison command execution '%s'. (cf_pclose: %s)", BufferData(expanded_command), GetErrorStr()); *result = PromiseResultUpdate(*result, PROMISE_RESULT_FAIL); BufferDestroy(expanded_command); return VERCMP_ERROR; } BufferDestroy(expanded_command); return retcode == 0; }
// -------------------------------------------------------------------------------------------------------------------- bool SimpleSolution::Init(const std::vector<RotationCubeProblem::Vertex>& _vertices, const std::vector<RotationCubeProblem::Index>& _indices, size_t _objectCount) { mObjectCount = _objectCount; mIndexCount = _indices.size(); // Program const char* kUniformNames[] = { "gTex", nullptr }; mProgram = CreateProgramT("cubes_gl_simple_vs.glsl", "cubes_gl_simple_fs.glsl", kUniformNames, &mUniformLocation); if (mProgram == 0) { console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str()); return false; } glGenVertexArrays(1, &mVertexArrayObject); glBindVertexArray(mVertexArrayObject); GLuint UB0 = glGetUniformBlockIndex(mProgram, "UB0"); glUniformBlockBinding(mProgram, UB0, 0); GLuint UB1 = glGetUniformBlockIndex(mProgram, "UB1"); glUniformBlockBinding(mProgram, UB1, 1); GLint uniformBufferOffsetAlignment = 0; glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &uniformBufferOffsetAlignment); mMatrixStride = iceil(sizeof(Matrix), uniformBufferOffsetAlignment); glGenBuffers(1, &mVertexBuffer); glGenBuffers(1, &mIndexBuffer); glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer); BufferData(GL_ARRAY_BUFFER, _vertices, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer); BufferData(GL_ELEMENT_ARRAY_BUFFER, _indices, GL_STATIC_DRAW); glGenBuffers(1, &mUniformBuffer0); glGenBuffers(1, &mUniformBuffer1); glGenVertexArrays(1, &mVAO); glBindVertexArray(mVAO); mStorage.resize(mMatrixStride); return glGetError() == GL_NO_ERROR; }
char *VarRefToString(const VarRef *ref, bool qualified) { assert(ref->lval); Buffer *buf = BufferNew(); if (qualified && VarRefIsQualified(ref)) { const char *ns = ref->ns ? ref->ns : "default"; BufferAppend(buf, ns, strlen(ns)); BufferAppend(buf, ":", sizeof(char)); BufferAppend(buf, ref->scope, strlen(ref->scope)); BufferAppend(buf, ".", sizeof(char)); } BufferAppend(buf, ref->lval, strlen(ref->lval)); for (size_t i = 0; i < ref->num_indices; i++) { BufferAppend(buf, "[", sizeof(char)); BufferAppend(buf, ref->indices[i], strlen(ref->indices[i])); BufferAppend(buf, "]", sizeof(char)); } char *var_string = xstrdup(BufferData(buf)); BufferDestroy(&buf); return var_string; }
static void ShowContextsFormatted(EvalContext *ctx) { ClassTableIterator *iter = EvalContextClassTableIteratorNewGlobal(ctx, NULL, true, true); Class *cls = NULL; Seq *seq = SeqNew(1000, free); while ((cls = ClassTableIteratorNext(iter))) { char *class_name = ClassRefToString(cls->ns, cls->name); StringSet *tagset = EvalContextClassTags(ctx, cls->ns, cls->name); Buffer *tagbuf = StringSetToBuffer(tagset, ','); char *line; xasprintf(&line, "%-60s %-40s", class_name, BufferData(tagbuf)); SeqAppend(seq, line); BufferDestroy(tagbuf); free(class_name); } SeqSort(seq, (SeqItemComparator)strcmp, NULL); printf("%-60s %-40s\n", "Class name", "Meta tags"); for (size_t i = 0; i < SeqLength(seq); i++) { const char *context = SeqAt(seq, i); printf("%s\n", context); } SeqDestroy(seq); ClassTableIteratorDestroy(iter); }
static void ShowVariablesFormatted(EvalContext *ctx) { VariableTableIterator *iter = EvalContextVariableTableIteratorNew(ctx, NULL, NULL, NULL); Variable *v = NULL; Seq *seq = SeqNew(2000, free); while ((v = VariableTableIteratorNext(iter))) { char *varname = VarRefToString(v->ref, true); Writer *w = StringWriter(); switch (DataTypeToRvalType(v->type)) { case RVAL_TYPE_CONTAINER: JsonWriteCompact(w, RvalContainerValue(v->rval)); break; default: RvalWrite(w, v->rval); } const char *var_value; if (StringIsPrintable(StringWriterData(w))) { var_value = StringWriterData(w); } else { var_value = "<non-printable>"; } StringSet *tagset = EvalContextVariableTags(ctx, v->ref); Buffer *tagbuf = StringSetToBuffer(tagset, ','); char *line; xasprintf(&line, "%-40s %-60s %-40s", varname, var_value, BufferData(tagbuf)); SeqAppend(seq, line); BufferDestroy(tagbuf); WriterClose(w); free(varname); } SeqSort(seq, (SeqItemComparator)strcmp, NULL); printf("%-40s %-60s %-40s\n", "Variable name", "Variable value", "Meta tags"); for (size_t i = 0; i < SeqLength(seq); i++) { const char *variable = SeqAt(seq, i); printf("%s\n", variable); } SeqDestroy(seq); VariableTableIteratorDestroy(iter); }
static uint32_t setup_quad_index_buffer(const GrGLInterface* gl) { static const int kMaxQuads = 1;//1 << 12; // max possible: (1 << 14) - 1; GR_STATIC_ASSERT(4 * kMaxQuads <= 65535); static const uint16_t kPattern[] = { 0, 1, 2, 0, 2, 3 }; static const int kPatternSize = 6; static const int kVertCount = 4; static const int kIndicesCount = kPatternSize * kMaxQuads; int size = kPatternSize * kMaxQuads * sizeof(uint16_t); uint16_t* data = SkNEW_ARRAY(uint16_t, kMaxQuads * kPatternSize); for (int i = 0; i < kMaxQuads; ++i) { int baseIdx = i * kPatternSize; uint16_t baseVert = (uint16_t)(i * kVertCount); for (int j = 0; j < kPatternSize; ++j) { data[baseIdx+j] = baseVert + kPattern[j]; } } GrGLuint quadIBO; GR_GL_CALL(gl, GenBuffers(1, &quadIBO)); GR_GL_CALL(gl, BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, quadIBO)); GR_GL_CALL(gl, BufferData(GR_GL_ELEMENT_ARRAY_BUFFER, size, data, GR_GL_STATIC_DRAW)); SkDELETE_ARRAY(data); return kIndicesCount; }
static void test_extract_reference_(const char *scalar, bool expect_success, const char *outer, const char *inner) { Buffer *b = BufferNew(); size_t len = strlen(scalar); bool success = ExtractScalarReference(b, scalar, len, false); assert_true(success == expect_success); assert_string_equal(outer, BufferData(b)); BufferClear(b); success = ExtractScalarReference(b, scalar, len, true); assert_true(success == expect_success); assert_string_equal(inner, BufferData(b)); BufferDestroy(b); }
bool GrGLVertexBuffer::updateData(const void* src, size_t srcSizeInBytes) { GrAssert(fBufferID); GrAssert(!isLocked()); if (srcSizeInBytes > size()) { return false; } this->bind(); GrGLenum usage = dynamic() ? GR_GL_DYNAMIC_DRAW : GR_GL_STATIC_DRAW; if (size() == srcSizeInBytes) { GR_GL(BufferData(GR_GL_ARRAY_BUFFER, srcSizeInBytes, src, usage)); } else { GR_GL(BufferData(GR_GL_ARRAY_BUFFER, size(), NULL, usage)); GR_GL(BufferSubData(GR_GL_ARRAY_BUFFER, 0, srcSizeInBytes, src)); } return true; }
void GLEmitter::Draw(RenderPhase phase, GLShader& shader) const { if(materialPhase != phase) return; BufferData(); shader.Bind(); shader.SetTexture(0, texture); glBindBuffer(GL_ARRAY_BUFFER, buffers[0]); glVertexAttribPointer(shader.attributeLocations[0], 4, GL_FLOAT, GL_FALSE, 4 * 10, 0); glVertexAttribPointer(shader.attributeLocations[1], 4, GL_FLOAT, GL_FALSE, 4 * 10, (GLvoid*)(4 * 4)); glVertexAttribPointer(shader.attributeLocations[2], 2, GL_FLOAT, GL_FALSE, 4 * 10, (GLvoid*)(8 * 4)); glEnableVertexAttribArray(shader.attributeLocations[0]); glEnableVertexAttribArray(shader.attributeLocations[1]); glEnableVertexAttribArray(shader.attributeLocations[2]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]); glDrawElements(GL_TRIANGLES, 6 * numParticles, GL_UNSIGNED_SHORT, 0); glDisableVertexAttribArray(shader.attributeLocations[0]); glDisableVertexAttribArray(shader.attributeLocations[1]); glDisableVertexAttribArray(shader.attributeLocations[2]); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glUseProgram(0); }
GrGLBuffer::GrGLBuffer(GrGLGpu* gpu, size_t size, GrGpuBufferType intendedType, GrAccessPattern accessPattern, const void* data) : INHERITED(gpu, size, intendedType, accessPattern) , fIntendedType(intendedType) , fBufferID(0) , fUsage(gr_to_gl_access_pattern(intendedType, accessPattern)) , fGLSizeInBytes(0) , fHasAttachedToTexture(false) { GL_CALL(GenBuffers(1, &fBufferID)); if (fBufferID) { GrGLenum target = gpu->bindBuffer(fIntendedType, this); CLEAR_ERROR_BEFORE_ALLOC(gpu->glInterface()); // make sure driver can allocate memory for this buffer GL_ALLOC_CALL(gpu->glInterface(), BufferData(target, (GrGLsizeiptr) size, data, fUsage)); if (CHECK_ALLOC_ERROR(gpu->glInterface()) != GR_GL_NO_ERROR) { GL_CALL(DeleteBuffers(1, &fBufferID)); fBufferID = 0; } else { fGLSizeInBytes = size; } } VALIDATE(); this->registerWithCache(SkBudgeted::kYes); if (!fBufferID) { this->resourcePriv().removeScratchKey(); } }
void GLCpuPosInstancedArraysBench::setupSingleVbo(const GrGLInterface* gl, const SkMatrix* viewMatrices) { // Constants for our various shader programs Vertex vertices[kVerticesPerTri * kNumTri]; for (uint32_t i = 0; i < kNumTri; i++) { Vertex* v = &vertices[i * kVerticesPerTri]; v[0].fPositions.set(-1.0f, -1.0f); v[1].fPositions.set( 1.0f, -1.0f); v[2].fPositions.set( 1.0f, 1.0f); SkPoint* position = reinterpret_cast<SkPoint*>(v); viewMatrices[i].mapPointsWithStride(position, sizeof(Vertex), kVerticesPerTri); // set colors float color = i == kNumTri - 1 ? 1.0f : 0.0f; for (uint32_t j = 0; j < kVerticesPerTri; j++) { uint32_t offset = 0; v->fColors[offset++] = color; v->fColors[offset++] = 0.0f; v->fColors[offset++] = 0.0f; v++; } } GrGLuint vbo; // setup VBO GR_GL_CALL(gl, GenBuffers(1, &vbo)); GR_GL_CALL(gl, BindBuffer(GR_GL_ARRAY_BUFFER, vbo)); GR_GL_CALL(gl, EnableVertexAttribArray(0)); GR_GL_CALL(gl, EnableVertexAttribArray(1)); GR_GL_CALL(gl, VertexAttribPointer(0, 2, GR_GL_FLOAT, GR_GL_FALSE, sizeof(Vertex), (GrGLvoid*)0)); GR_GL_CALL(gl, VertexAttribPointer(1, 3, GR_GL_FLOAT, GR_GL_FALSE, sizeof(Vertex), (GrGLvoid*)(sizeof(SkPoint)))); GR_GL_CALL(gl, BufferData(GR_GL_ARRAY_BUFFER, sizeof(vertices), vertices, GR_GL_STATIC_DRAW)); fBuffers.push_back(vbo); }
static void test_zeroBuffer(void) { char *element0 = xstrdup("element0"); unsigned int element0size = strlen(element0); const char *element0pointer = NULL; Buffer *buffer = BufferNew(); assert_int_equal(element0size, BufferSet(buffer, element0, element0size)); element0pointer = buffer->buffer; assert_int_equal(element0size, buffer->used); assert_int_equal(element0size, BufferSize(buffer)); BufferZero(buffer); assert_int_equal(DEFAULT_BUFFER_SIZE, buffer->capacity); assert_int_equal(0, buffer->used); assert_int_equal(0, BufferSize(buffer)); const char *data = BufferData(buffer); assert_string_equal(data, ""); assert_true(element0pointer == buffer->buffer); BufferZero(NULL); assert_int_equal(0, BufferDestroy(&buffer)); /* * Release the resources */ BufferDestroy(&buffer); free (element0); }
void CSave::WriteString( const char *pname, const int *stringId, int count ) { int i, size; #ifdef TOKENIZE short token = ( short ) TokenHash( STRING( *stringId ) ); WriteShort( pname, &token, 1 ); #else #if 0 if( count != 1 ) ALERT( at_error, "No string arrays!\n" ); WriteString( pname, ( char * ) STRING( *stringId ) ); #endif size = 0; for( i = 0; i < count; i++ ) size += strlen( STRING( stringId[ i ] ) ) + 1; BufferHeader( pname, size ); for( i = 0; i < count; i++ ) { const char *pString = STRING( stringId[ i ] ); BufferData( pString, strlen( pString ) + 1 ); } #endif }
const BufferData MLConnection::peekElements(uint elements) { #ifdef EDEBUG if (!theReader) { qWarning("*** WARNING: peekElements() cannot be called on an MLConnection object after\n" " killReader() has been called. Ignoring this call.\n"); return BufferData(); } #endif while (1) { BufferData ret = theReader->readElements(elements, false); theSink->checkExit(); if (!ret.plunger()) { if (type().isA<Mark>()) if (!Mark::isEndOfTime(ret)) m_latestTime = Mark::timestamp(ret); else{} else m_latestPeeked = m_samplesRead + elements / theType->size(); return ret; } m_samplesRead = 0; m_latestPeeked = 0; m_latestTime = 0.0; theReader->haveRead(ret); theSink->plunged(theSinkIndex); } }
static bool SaveBufferCallback(const char *dest_filename, void *param, NewLineMode new_line_mode) { FILE *fp = safe_fopen(dest_filename, (new_line_mode == NewLineMode_Native) ? "wt" : "w"); if (!fp) { Log(LOG_LEVEL_ERR, "Unable to open destination file '%s' for writing. (fopen: %s)", dest_filename, GetErrorStr()); return false; } Buffer *output_buffer = param; size_t bytes_written = fwrite(BufferData(output_buffer), sizeof(char), BufferSize(output_buffer), fp); if (bytes_written != BufferSize(output_buffer)) { Log(LOG_LEVEL_ERR, "Error writing to output file '%s' when writing. %zd bytes written but expected %d. (fclose: %s)", dest_filename, bytes_written, BufferSize(output_buffer), GetErrorStr()); fclose(fp); return false; } if (fclose(fp) == -1) { Log(LOG_LEVEL_ERR, "Unable to close file '%s' after writing. (fclose: %s)", dest_filename, GetErrorStr()); return false; } return true; }
// returns NULL on success, otherwise an error string const char* BufferSearchAndReplace(Buffer *buffer, const char *pattern, const char *substitute, const char *options) { assert(buffer); assert(pattern); assert(substitute); assert(options); int err; pcre_wrap_job *job = pcre_wrap_compile(pattern, substitute, options, &err); if (job == NULL) { return pcre_wrap_strerror(err); } size_t length = BufferSize(buffer); char *result; if (0 > (err = pcre_wrap_execute(job, (char*)BufferData(buffer), length, &result, &length))) { return pcre_wrap_strerror(err); } BufferSet(buffer, result, length); free(result); pcre_wrap_free_job(job); return NULL; }
static void test_generic_interface(void) { /* * This test might seem short, but it is intentional. * All the parsing tests should be implemented directly * on the corresponding parser test. Keep this test as * lean as possible. */ IPAddress *address = NULL; Buffer *buffer = NULL; buffer = BufferNew(); assert_true(buffer != NULL); BufferSet(buffer, "127.0.0.1", strlen("127.0.0.1")); address = IPAddressNew(buffer); assert_true(address != NULL); assert_int_equal(IP_ADDRESS_TYPE_IPV4, IPAddressType(address)); assert_string_equal("127.0.0.1", BufferData(IPAddressGetAddress(address))); assert_int_equal(0, IPAddressGetPort(address)); assert_int_equal(0, IPAddressDestroy(&address)); BufferSet(buffer, "127.0.0.1:8080", strlen("127.0.0.1:8080")); address = IPAddressNew(buffer); assert_true(address != NULL); assert_int_equal(IP_ADDRESS_TYPE_IPV4, IPAddressType(address)); assert_string_equal("127.0.0.1", BufferData(IPAddressGetAddress(address))); assert_int_equal(8080, IPAddressGetPort(address)); assert_int_equal(0, IPAddressDestroy(&address)); BufferSet(buffer, "0:1:2:3:4:5:6:7", strlen("0:1:2:3:4:5:6:7")); address = IPAddressNew(buffer); assert_true(address != NULL); assert_int_equal(IP_ADDRESS_TYPE_IPV6, IPAddressType(address)); assert_string_equal("0:1:2:3:4:5:6:7", BufferData(IPAddressGetAddress(address))); assert_int_equal(0, IPAddressGetPort(address)); assert_int_equal(0, IPAddressDestroy(&address)); BufferSet(buffer, "[0:1:2:3:4:5:6:7]:9090", strlen("[0:1:2:3:4:5:6:7]:9090")); address = IPAddressNew(buffer); assert_true(address != NULL); assert_int_equal(IP_ADDRESS_TYPE_IPV6, IPAddressType(address)); assert_string_equal("0:1:2:3:4:5:6:7", BufferData(IPAddressGetAddress(address))); assert_int_equal(9090, IPAddressGetPort(address)); assert_int_equal(0, IPAddressDestroy(&address)); BufferDestroy(buffer); }
void BufferRewrite(Buffer *buffer, BufferFilterFn filter, const bool invert) { assert(buffer); Buffer *rewrite = BufferFilter(buffer, filter, invert); BufferSet(buffer, BufferData(rewrite), BufferSize(rewrite)); BufferDestroy(rewrite); }
void GLEmitter::Update() { for(int i = 0; i < numParticles; i++) { } BufferData(); }
void VBO::GenBuffers(GLenum usage) { glGenBuffers(5, buffers); glBindBuffer(GL_ARRAY_BUFFER, vertex); BufferData(GL_ARRAY_BUFFER, Mesh::vertexes, usage); /* glBindBuffer(GL_ARRAY_BUFFER, texCoord); BufferData(GL_ARRAY_BUFFER, Mesh::texCoords, usage); glBindBuffer(GL_ARRAY_BUFFER, normal); BufferData(GL_ARRAY_BUFFER, Mesh::normals, usage); glBindBuffer(GL_ARRAY_BUFFER, color); BufferData(GL_ARRAY_BUFFER, Mesh::colors, usage); */ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, element); BufferData(GL_ELEMENT_ARRAY_BUFFER, Mesh::faces, usage); }