void IMB_exr_read_channels(void *handle) { ExrHandle *data = (ExrHandle *)handle; FrameBuffer frameBuffer; ExrChannel *echan; /* check if exr was saved with previous versions of blender which flipped images */ const StringAttribute *ta = data->ifile->header().findTypedAttribute <StringAttribute> ("BlenderMultiChannel"); short flip = (ta && strncmp(ta->value().c_str(), "Blender V2.43", 13) == 0); /* 'previous multilayer attribute, flipped */ for (echan = (ExrChannel *)data->channels.first; echan; echan = echan->next) { if (echan->rect) { if (flip) frameBuffer.insert(echan->name, Slice(Imf::FLOAT, (char *)echan->rect, echan->xstride * sizeof(float), echan->ystride * sizeof(float))); else frameBuffer.insert(echan->name, Slice(Imf::FLOAT, (char *)(echan->rect + echan->xstride * (data->height - 1) * data->width), echan->xstride * sizeof(float), -echan->ystride * sizeof(float))); } else printf("warning, channel with no rect set %s\n", echan->name); } data->ifile->setFrameBuffer(frameBuffer); try { data->ifile->readPixels(0, data->height - 1); } catch (const std::exception &exc) { std::cerr << "OpenEXR-readPixels: ERROR: " << exc.what() << std::endl; } }
static int imb_save_openexr_float(struct ImBuf *ibuf, const char *name, int flags) { const int channels = ibuf->channels; const int is_alpha = (channels >= 4) && (ibuf->planes == 32); const int is_zbuf = (flags & IB_zbuffloat) && ibuf->zbuf_float != NULL; /* summarize */ const int width = ibuf->x; const int height = ibuf->y; try { Header header(width, height); openexr_header_compression(&header, ibuf->ftype & OPENEXR_COMPRESS); openexr_header_metadata(&header, ibuf); header.channels().insert("R", Channel(Imf::FLOAT)); header.channels().insert("G", Channel(Imf::FLOAT)); header.channels().insert("B", Channel(Imf::FLOAT)); if (is_alpha) header.channels().insert("A", Channel(Imf::FLOAT)); if (is_zbuf) header.channels().insert("Z", Channel(Imf::FLOAT)); FrameBuffer frameBuffer; /* manually create ofstream, so we can handle utf-8 filepaths on windows */ OFileStream file_stream(name); OutputFile file(file_stream, header); int xstride = sizeof(float) * channels; int ystride = -xstride * width; float *rect[4] = {NULL, NULL, NULL, NULL}; /* last scanline, stride negative */ rect[0] = ibuf->rect_float + channels * (height - 1) * width; rect[1] = (channels >= 2) ? rect[0] + 1 : rect[0]; rect[2] = (channels >= 3) ? rect[0] + 2 : rect[0]; rect[3] = (channels >= 4) ? rect[0] + 3 : rect[0]; /* red as alpha, is this needed since alpha isn't written? */ frameBuffer.insert("R", Slice(Imf::FLOAT, (char *)rect[0], xstride, ystride)); frameBuffer.insert("G", Slice(Imf::FLOAT, (char *)rect[1], xstride, ystride)); frameBuffer.insert("B", Slice(Imf::FLOAT, (char *)rect[2], xstride, ystride)); if (is_alpha) frameBuffer.insert("A", Slice(Imf::FLOAT, (char *)rect[3], xstride, ystride)); if (is_zbuf) frameBuffer.insert("Z", Slice(Imf::FLOAT, (char *) (ibuf->zbuf_float + (height - 1) * width), sizeof(float), sizeof(float) * -width)); file.setFrameBuffer(frameBuffer); file.writePixels(height); } catch (const std::exception &exc) { printf("OpenEXR-save: ERROR: %s\n", exc.what()); return (0); } return (1); // printf("OpenEXR-save: Done.\n"); }
void IMB_exr_write_channels(void *handle) { ExrHandle *data = (ExrHandle *)handle; FrameBuffer frameBuffer; ExrChannel *echan; if (data->channels.first) { for (echan = (ExrChannel *)data->channels.first; echan; echan = echan->next) { /* last scanline, stride negative */ float *rect = echan->rect + echan->xstride * (data->height - 1) * data->width; frameBuffer.insert(echan->name, Slice(Imf::FLOAT, (char *)rect, echan->xstride * sizeof(float), -echan->ystride * sizeof(float))); } data->ofile->setFrameBuffer(frameBuffer); try { data->ofile->writePixels(data->height); } catch (const std::exception &exc) { std::cerr << "OpenEXR-writePixels: ERROR: " << exc.what() << std::endl; } } else { printf("Error: attempt to save MultiLayer without layers.\n"); } }
PipeLine::PipeLine(FrameBuffer& fbo,int regsN) :fbo_(fbo),registers_(regsN), uniforms_((Uniforms*)registers_.regs_.data()), worldTransform_(), viewfrustum_(), cam_(viewfrustum_,0.1,0.01) { setCullState(FT_CCW,CT_BACK); viewfrustum_.setFrustum(90.0f,fbo.width(),fbo.height(),5,500); //viewfrustum_.setFrustum(-400,400,-300,300,50,500); setViewPort(fbo.width(),fbo.height(),0,0); uniforms_->wpvMatrix_ = viewfrustum_.getProjectionViewMatrix(); using PT = Mesh::PrimitiveT; // FIXME //drawFunction_[PT::POLYPOINT] = &PipeLine::drawPolypoint; //drawFunction_[PT::POLYSEGMENT_DISJOINT] = &PipeLine::drawPolylineDisjoint; //drawFunction_[PT::POLYSEGMENT_CONTIGUOUS] = &PipeLine::drawPolylineContiguous; //drawFunction_[PT::TRISTRIP]= drawFunction_[PT::TRIMESH] = &PipeLine::drawTriMesh; rasterAlgo_[RasAlgo::SCANLINE_ALGO] = &PipeLine::scanlineAlgo; }
void SSAOShader::generateRandomTexture(){ // Genero un request para la nueva textura de random a crear GraphicDeviceConstantCatalog* catalog = GraphicDevice::getInstance()->getConstantCatalog(); FrameBufferRequest* request = new FrameBufferRequest(); TextureRequest* textureRequest = new TextureRequest(4, 4, catalog->getFormatRGB(), catalog->getFormatRGB()); textureRequest->addFilterRequest(new TextureFilterRequest(catalog->getTextureMagFilterFlag(), catalog->getTextureNearestFilterFlag())); textureRequest->addFilterRequest(new TextureFilterRequest(catalog->getTextureMinFilterFlag(), catalog->getTextureNearestFilterFlag())); textureRequest->addFilterRequest(new TextureFilterRequest(catalog->getTextureWrapSFlag(), catalog->getTextureRepeatFlag())); textureRequest->addFilterRequest(new TextureFilterRequest(catalog->getTextureWrapTFlag(), catalog->getTextureRepeatFlag())); request->addTextureRequest(textureRequest); // Consigo un fbo, dibujo en el, y vuelvo al fbo anterior FrameBuffer* currentFbo = FrameBufferManager::getInstance()->getActiveFrameBuffer(); static FrameBuffer* randomTextureFbo = NULL; if(randomTextureFbo != NULL){ randomTextureFbo->getOutputTextures()->at(0)->setWriteLock(false); } randomTextureFbo = FrameBufferManager::getInstance()->getFrameBufferAndBind(request, randomTextureFbo); GraphicDevice::getInstance()->setViewport(0, 0, 4, 4); RandomTextureGeneratorShader::getInstance()->draw(vec2(4, 4), 0.0f, 1.0f); currentFbo->bind(); vec2 size = currentFbo->getOutputTextures()->at(0)->getSize(); GraphicDevice::getInstance()->setViewport(0, 0, size.x, size.y); // Me guardo la textura (no libero el writelock del fbo, porque sino se me borra la textura) this->randomTexture = randomTextureFbo->getOutputTextures()->at(0); delete request; }
void TiledRgbaOutputFile::setFrameBuffer (const Rgba *base, size_t xStride, size_t yStride) { if (_toYa) { Lock lock (*_toYa); _toYa->setFrameBuffer (base, xStride, yStride); } else { size_t xs = xStride * sizeof (Rgba); size_t ys = yStride * sizeof (Rgba); FrameBuffer fb; fb.insert ("R", Slice (HALF, (char *) &base[0].r, xs, ys)); fb.insert ("G", Slice (HALF, (char *) &base[0].g, xs, ys)); fb.insert ("B", Slice (HALF, (char *) &base[0].b, xs, ys)); fb.insert ("A", Slice (HALF, (char *) &base[0].a, xs, ys)); _outputFile->setFrameBuffer (fb); } }
bool ProtocolDHCP::parseOption(const FrameBuffer& buffer, size_t& offset) { if (buffer.sizeBytes() <= offset) { return false; } Poco::UInt8 type = buffer[offset]; if (type == 0xff) { return false; } if (buffer.sizeBytes() <= offset) { return false; } offset++; Poco::UInt8 length = buffer[offset]; offset++; if (!enoughFor(buffer, offset, length)) { return false; } std::string data((const char*)(buffer.begin()+offset), length); offset += length; _options[type] = data; return true; }
void CompositeDeepScanLine::setFrameBuffer(const FrameBuffer& fr) { // // count channels; build map between channels in frame buffer // and channels in internal buffers // _Data->_channels.resize(3); _Data->_channels[0]="Z"; _Data->_channels[1]=_Data->_zback ? "ZBack" : "Z"; _Data->_channels[2]="A"; _Data->_bufferMap.resize(0); for(FrameBuffer::ConstIterator q=fr.begin();q!=fr.end();q++) { string name(q.name()); if(name=="ZBack") { _Data->_bufferMap.push_back(1); }else if(name=="Z") { _Data->_bufferMap.push_back(0); }else if(name=="A") { _Data->_bufferMap.push_back(2); }else{ _Data->_bufferMap.push_back(_Data->_channels.size()); _Data->_channels.push_back(name); } } _Data->_outputFrameBuffer=fr; }
static bool ReadEXR(const char *name, float *&rgba, int &xRes, int &yRes, bool &hasAlpha) { InputFile file(name); Box2i dw = file.header().dataWindow(); xRes = dw.max.x - dw.min.x + 1; yRes = dw.max.y - dw.min.y + 1; half *hrgba = new half[4 * xRes * yRes]; // for now... hasAlpha = true; int nChannels = 4; half *hp = hrgba - nChannels * (dw.min.x + dw.min.y * xRes); FrameBuffer frameBuffer; frameBuffer.insert("R", Slice(HALF, (char *)hp, 4*sizeof(half), xRes * 4 * sizeof(half), 1, 1, 0.0)); frameBuffer.insert("G", Slice(HALF, (char *)hp+sizeof(half), 4*sizeof(half), xRes * 4 * sizeof(half), 1, 1, 0.0)); frameBuffer.insert("B", Slice(HALF, (char *)hp+2*sizeof(half), 4*sizeof(half), xRes * 4 * sizeof(half), 1, 1, 0.0)); frameBuffer.insert("A", Slice(HALF, (char *)hp+3*sizeof(half), 4*sizeof(half), xRes * 4 * sizeof(half), 1, 1, 1.0)); file.setFrameBuffer(frameBuffer); file.readPixels(dw.min.y, dw.max.y); rgba = new float[nChannels * xRes * yRes]; for (int i = 0; i < nChannels * xRes * yRes; ++i) rgba[i] = hrgba[i]; delete[] hrgba; return rgba; }
void readEXRRED(const char* filename, int width, int height, float* data) { InputFile file(filename); Box2i dw = file.header().dataWindow(); int size = (width)*(height); half *rPixels = new half[size]; FrameBuffer frameBuffer; frameBuffer.insert ("R", // name Slice (HALF, // type (char *) rPixels, sizeof (*rPixels) * 1, // xStride sizeof (*rPixels) * (width),// yStride 1, 1, // x/y sampling 0.0)); // fillValue file.setFrameBuffer (frameBuffer); file.readPixels (dw.min.y, dw.max.y); for(int j=0; j<height; j++) for(int i=0; i<width; i++) { data[j*width+i] = rPixels[(height-1-j)*width+i]; } delete[] rPixels; }
int main() { printf("start of program\n"); FrameBuffer FB; FB.initAvailable(); Polygon pmouth(0, 0, 0, mouth, 18); pmouth.setPosition(0, 0, 0); pmouth.setMultiplication(10); pmouth.setCenter(0, 0, 0); pmouth.setFillColor(135, 206, 250); static Polygon* arrStar[] = { &pmouth }; vector<Polygon*> star(arrStar, arrStar + sizeof(arrStar) / sizeof(arrStar[0]) ); FB.canvas(); FB.draw(star); //FB.drawBeizer(star); FB.render(); return 0; }
void WriteEXR(const char *name, float *frgba, int xRes, int yRes, bool hasAlpha) { Header header(xRes, yRes); header.channels().insert("R", Channel (HALF)); header.channels().insert("G", Channel (HALF)); header.channels().insert("B", Channel (HALF)); if (hasAlpha) header.channels().insert("A", Channel (HALF)); int stride = hasAlpha ? 4 : 3; half *rgba = new half[xRes*yRes * stride]; for (int i = 0; i < xRes*yRes * stride; ++i) rgba[i] = frgba[i]; FrameBuffer fb; fb.insert("R", Slice(HALF, (char *)rgba, stride*sizeof(half), stride*xRes*sizeof(half))); fb.insert("G", Slice(HALF, (char *)rgba+sizeof(half), stride*sizeof(half), stride*xRes*sizeof(half))); fb.insert("B", Slice(HALF, (char *)rgba+2*sizeof(half), stride*sizeof(half), stride*xRes*sizeof(half))); if (hasAlpha) fb.insert("A", Slice(HALF, (char *)rgba+3*sizeof(half), stride*sizeof(half), stride*xRes*sizeof(half))); OutputFile file(name, header); file.setFrameBuffer(fb); file.writePixels(yRes); }
Result_t ASDCP::TimedText::DCSubtitleParser::h__SubtitleParser::ReadAncillaryResource(const byte_t* uuid, FrameBuffer& FrameBuf, const IResourceResolver& Resolver) const { FrameBuf.AssetID(uuid); UUID TmpID(uuid); char buf[64]; ResourceTypeMap_t::const_iterator rmi = m_ResourceTypes.find(TmpID); if ( rmi == m_ResourceTypes.end() ) { DefaultLogSink().Error("Unknown ancillary resource id: %s\n", TmpID.EncodeHex(buf, 64)); return RESULT_RANGE; } Result_t result = Resolver.ResolveRID(uuid, FrameBuf); if ( KM_SUCCESS(result) ) { if ( (*rmi).second == MT_PNG ) FrameBuf.MIMEType("image/png"); else if ( (*rmi).second == MT_OPENTYPE ) FrameBuf.MIMEType("application/x-font-opentype"); else FrameBuf.MIMEType("application/octet-stream"); } return result; }
void PostProcessing::renderMotionBlur(unsigned , FrameBuffer &in_fbo, FrameBuffer &out_fbo) { MotionBlurProvider * const cb = (MotionBlurProvider *)irr_driver-> getCallback(ES_MOTIONBLUR); Camera *cam = Camera::getActiveCamera(); unsigned camID = cam->getIndex(); scene::ICameraSceneNode * const camnode = cam->getCameraSceneNode(); // Calculate the kart's Y position on screen if (cam->getKart()) { const core::vector3df pos = cam->getKart()->getNode()->getPosition(); float ndc[4]; core::matrix4 trans = camnode->getProjectionMatrix(); trans *= camnode->getViewMatrix(); trans.transformVect(ndc, pos); const float karty = (ndc[1] / ndc[3]) * 0.5f + 0.5f; setMotionBlurCenterY(camID, karty); } else setMotionBlurCenterY(camID, 0.5f); out_fbo.Bind(); glClear(GL_COLOR_BUFFER_BIT); FullScreenShader::MotionBlurShader::getInstance()->SetTextureUnits(in_fbo.getRTT()[0], irr_driver->getDepthStencilTexture()); DrawFullScreenEffect<FullScreenShader::MotionBlurShader>( // Todo : use a previousPVMatrix per cam, not global cam->getPreviousPVMatrix(), core::vector2df(0.5, 0.5), cb->getBoostTime(cam->getIndex()) * 10, // Todo : should be framerate dependent 0.15f); }
// EXR Function Definitions COREDLL Spectrum *ReadImage(const string &name, int *width, int *height) { try { InputFile file(name.c_str()); Box2i dw = file.header().dataWindow(); *width = dw.max.x - dw.min.x + 1; *height = dw.max.y - dw.min.y + 1; half *rgb = new half[3 * *width * *height]; FrameBuffer frameBuffer; frameBuffer.insert("R", Slice(HALF, (char *)rgb, 3*sizeof(half), *width * 3 * sizeof(half), 1, 1, 0.0)); frameBuffer.insert("G", Slice(HALF, (char *)rgb+sizeof(half), 3*sizeof(half), *width * 3 * sizeof(half), 1, 1, 0.0)); frameBuffer.insert("B", Slice(HALF, (char *)rgb+2*sizeof(half), 3*sizeof(half), *width * 3 * sizeof(half), 1, 1, 0.0)); file.setFrameBuffer(frameBuffer); file.readPixels(dw.min.y, dw.max.y); Spectrum *ret = new Spectrum[*width * *height]; // XXX should do real RGB -> Spectrum conversion here for (int i = 0; i < *width * *height; ++i) { float c[3] = { rgb[3*i], rgb[3*i+1], rgb[3*i+2] }; ret[i] = Spectrum(c); } delete[] rgb; return ret; } catch (const std::exception &e) { Error("Unable to read image file \"%s\": %s", name.c_str(), e.what()); return NULL; } }
void drawImage(Texture &_texture, ShaderProgram _program) { glViewport(0, 0, 640, 480); DriverGPU *driver = DriverGPU::get(); // create a RGBA color texture Texture colorTex(640, 480, eTexType::eRGB8); // create the framebuffer object FrameBuffer fbo; fbo.attachTexture(colorTex); fbo.linkAttachments(); _program.use(); _texture.attachToUniform(_program, "texture"); driver->drawQuadTextured2f( std::array < vec2f, 4 > {{vec2f(-1.0f, -1.0f), vec2f(1.0f, -1.0f), vec2f(1.0f, 1.0f), vec2f(-1.0f, 1.0f)}}, std::array < vec2f, 4 > {{vec2f(1.0f, 0.0f), vec2f(1.0f, 1.0f), vec2f(0.0f, 1.0f), vec2f(0.0f, 0.0f)}}); glFlush(); //fbo.detachTexture(colorTex); colorTex.saveTexture("./result.bmp"); glFinish(); std::cout << "finished" << std::endl; }
void setPostCallback(OnPostFn onPost, void* onPostContext) { FrameBuffer* fb = FrameBuffer::getFB(); if (fb) { fb->setPostCallback(onPost, onPostContext); } }
void writeTiled1 (const char fileName[], Array2D<GZ> &pixels, int width, int height, int tileWidth, int tileHeight) { Header header (width, height); header.channels().insert ("G", Channel (IMF::HALF)); header.channels().insert ("Z", Channel (IMF::FLOAT)); header.setTileDescription (TileDescription (tileWidth, tileHeight, ONE_LEVEL)); TiledOutputFile out (fileName, header); FrameBuffer frameBuffer; frameBuffer.insert ("G", // name Slice (IMF::HALF, // type (char *) &pixels[0][0].g, // base sizeof (pixels[0][0]) * 1, // xStride sizeof (pixels[0][0]) * width)); // yStride frameBuffer.insert ("Z", // name Slice (IMF::FLOAT, // type (char *) &pixels[0][0].z, // base sizeof (pixels[0][0]) * 1, // xStride sizeof (pixels[0][0]) * width)); // yStride out.setFrameBuffer (frameBuffer); out.writeTiles (0, out.numXTiles() - 1, 0, out.numYTiles() - 1); }
int main(int argc, char **argv) { Configuration *config = Configuration::instance("frconfig.cfg"); config->parse(); FrameBuffer *fb = FrameBuffer::instance( config->get("framebuffer", "device"), config->get("console", "device")); if (!fb->open()) { fprintf(stderr, "open frame buffer failed\n"); return 1; } char msg[] = "Frame Buffer test program"; fb->create_window("main"); fb->window().set_color(0, 0x000000); fb->window().set_color(1, 0xffe080); fb->window().fill_rect(0, 0, fb->get_xres() - 1, fb->get_yres() - 1, 0); fb->window().put_string_center(fb->get_xres()/2, fb->get_yres()/2, msg, 1); fb->close(); return 0; }
ASDCP::Result_t ASDCP::TimedText::MXFReader::h__Reader::ReadAncillaryResource(const byte_t* uuid, FrameBuffer& frame_buf, AESDecContext* Ctx, HMACContext* HMAC) { KM_TEST_NULL_L(uuid); UUID RID(uuid); ResourceMap_t::const_iterator ri = m_ResourceMap.find(RID); if ( ri == m_ResourceMap.end() ) { char buf[64]; DefaultLogSink().Error("No such resource: %s\n", RID.EncodeHex(buf, 64)); return RESULT_RANGE; } // get the subdescriptor InterchangeObject* tmp_iobj = 0; Result_t result = m_HeaderPart.GetMDObjectByID((*ri).second, &tmp_iobj); TimedTextResourceSubDescriptor* desc_object = dynamic_cast<TimedTextResourceSubDescriptor*>(tmp_iobj); if ( KM_SUCCESS(result) ) { assert(desc_object); result = ReadGenericStreamPartitionPayload(desc_object->EssenceStreamID, frame_buf, Ctx, HMAC); } if ( KM_SUCCESS(result) ) { frame_buf.AssetID(uuid); frame_buf.MIMEType(desc_object->MIMEMediaType); } return result; }
bool WindowSurface::blitToColorBuffer() { if (!m_width && !m_height) return false; if (m_attachedColorBuffer->getWidth() != m_width || m_attachedColorBuffer->getHeight() != m_height) { // XXX: should never happen - how this needs to be handled? fprintf(stderr, "Dimensions do not match\n"); return false; } // // Make the surface current // EGLContext prevContext = s_egl.eglGetCurrentContext(); EGLSurface prevReadSurf = s_egl.eglGetCurrentSurface(EGL_READ); EGLSurface prevDrawSurf = s_egl.eglGetCurrentSurface(EGL_DRAW); FrameBuffer *fb = FrameBuffer::getFB(); if (!m_drawContext.Ptr()) { fprintf(stderr, "Draw context is NULL\n"); return false; } if (!s_egl.eglMakeCurrent(fb->getDisplay(), m_eglSurface, m_eglSurface, m_drawContext->getEGLContext())) { fprintf(stderr, "Error making draw context current\n"); return false; } m_attachedColorBuffer->blitFromCurrentReadBuffer(); // restore current context/surface s_egl.eglMakeCurrent(fb->getDisplay(), prevDrawSurf, prevReadSurf, prevContext); return true; }
Result_t OpenReadFrame(const char* filename, FrameBuffer& FB) { ASDCP_TEST_NULL_STR(filename); m_File.Close(); Result_t result = m_File.OpenRead(filename); if ( ASDCP_SUCCESS(result) ) { Kumu::fsize_t file_size = m_File.Size(); if ( FB.Capacity() < file_size ) { DefaultLogSink().Error("FrameBuf.Capacity: %u frame length: %u\n", FB.Capacity(), (ui32_t)file_size); return RESULT_SMALLBUF; } } ui32_t read_count; if ( ASDCP_SUCCESS(result) ) result = m_File.Read(FB.Data(), FB.Capacity(), &read_count); if ( ASDCP_SUCCESS(result) ) FB.Size(read_count); return result; }
Texture2D Texture2D::createLinkedWith(FrameBuffer &buffer) { Texture2D ret; ret.m_id = ResourceHeap::instance().create(textureConstructor, textureDestructor, ResourceHeap::Texture2D); ret.bind(); // Set filtering parameters useParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); useParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR); if (GLEW_EXT_texture_filter_anisotropic) { int maxAnisotropy = 0; glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy); useParameter(GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy); } // Link texture with framebuffer glTexImage2D(GL_TEXTURE_2D, /*level*/0, GL_RGBA, buffer.width(), buffer.height(), /*border*/ 0, GL_RGBA, GL_UNSIGNED_BYTE, /*pixels from FB*/ nullptr); glGenerateMipmapEXT(GL_TEXTURE_2D); // Link framebuffer with texture glFramebufferTexture2DEXT( buffer.type(), GL_COLOR_ATTACHMENT0_EXT, // attachment point GL_TEXTURE_2D, ret.m_id, 0 // initial mip-level ); return ret; }
void printLetterCounter(int font1[][2], int col1, int font2[][2], int col2, float size, int x, int y) { if(y > 0 && y < 512-size*y) { vector<Point> points; vector<Point> points2; points.clear(); for(int i=0;i<col1-1;i++) { points.push_back(Point(font1[i][0]*size+size*x,font1[i][1]*size+size*y)); } Polygon Poly1(points); FB.drawPolygon(Poly1.e,25,25,122,0); points2.clear(); for(int i=0;i<col2-1;i++) { points2.push_back(Point(font2[i][0]*size+size*x,font2[i][1]*size+size*y)); } Polygon Poly2(points2); FB.drawPolygon(Poly2.e,25,25,122,0); Poly1.firePoint = Point(font1[col1-1][0]*size+size*x,font1[col1-1][1]*size+size*y); FB.floodFill(Poly1.firePoint.x, Poly1.firePoint.y, 255, 182, 193, 100, 149, 237); } else { //gausah digambar } }
ASDCP::Result_t ASDCP::DCData::SequenceParser::h__SequenceParser::OpenRead() { if ( m_FileList.empty() ) return RESULT_ENDOFFILE; m_CurrentFile = m_FileList.begin(); BytestreamParser Parser; FrameBuffer TmpBuffer; Kumu::fsize_t file_size = Kumu::FileSize((*m_CurrentFile).c_str()); if ( file_size == 0 ) return RESULT_NOT_FOUND; assert(file_size <= 0xFFFFFFFFL); Result_t result = TmpBuffer.Capacity((ui32_t) file_size); if ( ASDCP_SUCCESS(result) ) result = Parser.OpenReadFrame((*m_CurrentFile).c_str(), TmpBuffer); if ( ASDCP_SUCCESS(result) ) result = Parser.FillDCDataDescriptor(m_DDesc); // how big is it? if ( ASDCP_SUCCESS(result) ) m_DDesc.ContainerDuration = m_FileList.size(); return result; }
void readTiled1 (const char fileName[], Array2D<GZ> &pixels, int &width, int &height) { TiledInputFile in (fileName); Box2i dw = in.header().dataWindow(); width = dw.max.x - dw.min.x + 1; height = dw.max.y - dw.min.y + 1; int dx = dw.min.x; int dy = dw.min.y; pixels.resizeErase (height, width); FrameBuffer frameBuffer; frameBuffer.insert ("G", // name Slice (IMF::HALF, // type (char *) &pixels[-dy][-dx].g, // base sizeof (pixels[0][0]) * 1, // xStride sizeof (pixels[0][0]) * width)); // yStride frameBuffer.insert ("Z", // name Slice (IMF::FLOAT, // type (char *) &pixels[-dy][-dx].z, // base sizeof (pixels[0][0]) * 1, // xStride sizeof (pixels[0][0]) * width)); // yStride in.setFrameBuffer (frameBuffer); in.readTiles (0, in.numXTiles() - 1, 0, in.numYTiles() - 1); }
void RgbaInputFile::setFrameBuffer (Rgba *base, size_t xStride, size_t yStride) { size_t xs = xStride * sizeof (Rgba); size_t ys = yStride * sizeof (Rgba); FrameBuffer fb; fb.insert ("R", Slice (HALF, (char *) base + offsetof (Rgba, r), xs, ys, 1, 1, // xSampling, ySampling 0.0)); // fillValue fb.insert ("G", Slice (HALF, (char *) base + offsetof (Rgba, g), xs, ys, 1, 1, // xSampling, ySampling 0.0)); // fillValue fb.insert ("B", Slice (HALF, (char *) base + offsetof (Rgba, b), xs, ys, 1, 1, // xSampling, ySampling 0.0)); // fillValue fb.insert ("A", Slice (HALF, (char *) base + offsetof (Rgba, a), xs, ys, 1, 1, // xSampling, ySampling 1.0)); // fillValue _inputFile->setFrameBuffer (fb); }
void ShowRenderer::Render( double i_dt) { std::chrono::high_resolution_clock::duration pShowTime = std::chrono::high_resolution_clock::now() - m_startTime; float pShowSeconds = ((float) pShowTime.count()) / ((float) std::chrono::high_resolution_clock::period::den); if ( m_events.size() > 0 ) { while ( m_events[0].m_time <= pShowSeconds ) { if ( m_events.size() <= 0 ) break; float pTime = m_events[0].m_time; if ( strcmp( m_events[0].m_command.substr( 0, 5 ).c_str(), "mode " ) == 0 ) ChangeMode( m_events[0].m_command.substr( 5 ) ); cout << m_events[0].m_command << endl; m_events.erase ( m_events.begin(), m_events.begin()+1 ); } } if ( m_beats.size() > 0 ) { while ( m_beats[0] <= pShowSeconds ) { if ( m_beats.size() <= 0 ) break; float beat = m_beats[0]; float pNextBeat = beat + 1.0f; if ( m_beats.size() > 1 ) pNextBeat = m_beats[1]; float pTimeToNextBeat = pNextBeat - beat; if ( pTimeToNextBeat > 0.0f ) { if ( m_impulseFX ) { m_impulseFX->Impulse( RGBA( 255, 0, 0, 255 ), pTimeToNextBeat * 0.5f ); } } m_beats.erase ( m_beats.begin(), m_beats.begin()+1 ); } } FrameBuffer* pFrameBuffer = FrameBuffer::Instance(); for ( int i = 0; i < m_activeFX.size(); i++ ) { if ( m_activeFX[i]->IsActive() ) { m_activeFX[i]->Update( i_dt ); } else { RemoveFX( m_activeFX[i] ); } } pFrameBuffer->Update( i_dt ); }
static void rcCloseColorBuffer(uint32_t colorbuffer) { FrameBuffer *fb = FrameBuffer::getFB(); if (!fb) { return; } fb->closeColorBuffer( colorbuffer ); }
static int rcOpenColorBuffer2(uint32_t colorbuffer) { FrameBuffer *fb = FrameBuffer::getFB(); if (!fb) { return -1; } return fb->openColorBuffer( colorbuffer ); }