Renderer::ITessellationControlShader *ShaderLanguageHlsl::createTessellationControlShaderFromBytecode(const uint8_t *bytecode, uint32_t numberOfBytes) { // "hull shader" in Direct3D terminology // There's no need to check for "Renderer::Capabilities::maximumNumberOfPatchVertices", we know there's tessellation control shader support return new TessellationControlShaderHlsl(static_cast<Direct3D11Renderer&>(getRenderer()), bytecode, numberOfBytes); }
void FreesteelWindow2::showAll() { I1 xrg(1000,-1000), yrg(1000,-1000), zrg(1000,-1000); xrg.Absorb(surface->xrg, true); yrg.Absorb(surface->yrg, true); zrg.Absorb(surface->zrg, true); getRenderer()->GetActiveCamera()->SetFocalPoint(xrg.Half(), yrg.Half(), zrg.Half()); getRenderer()->GetActiveCamera()->SetPosition(xrg.Half(), yrg.Half(), zrg.hi + 100); // scale to fill window ASSERT(getRenderer()->GetActiveCamera()->GetParallelProjection() != 0); double scale = getRenderer()->GetActiveCamera()->GetParallelScale(); getRenderer()->GetActiveCamera()->SetParallelScale(max(xrg.Leng(), yrg.Leng())); }
int FreesteelWindow::add(GSTbase* gst) { gstees.push_back(gst); gst->AddToRenderer(getRenderer()); return(gstees.size() - 1); }
void HdrApp::render() { // Screen size int w = screenW; int h = screenH; // Render scene in HDR and RGB on separate render texture renderHdr(); renderRgb(); // Render to real framebuffer getRenderer()->clearBuffer(); // HACK split-screen // left side -> LDR // right side -> HDR // Draw RGB render texture on left part of the screen rtRgb->bind(); cam->initQuad(w, h); cam->drawQuadLeft(); // Draw HDR render texture on right part of the screen rtHdr->bind(); cam->initQuad(w, h); cam->drawQuadRight(); // Draw text renderText(); }
void ShaderCompiler::parseDependencies() { m_dependencies.clear(); bool is_opengl = getRenderer().isOpenGL(); Lumix::StaticString<30> compiled_dir("shaders/compiled", is_opengl ? "_gl" : ""); auto* iter = PlatformInterface::createFileIterator(compiled_dir, m_editor.getAllocator()); auto& fs = m_editor.getEngine().getFileSystem(); PlatformInterface::FileInfo info; while (PlatformInterface::getNextFile(iter, &info)) { if (!Lumix::PathUtils::hasExtension(info.filename, "d")) continue; auto* file = fs.open(fs.getDiskDevice(), Lumix::Path(Lumix::StaticString<Lumix::MAX_PATH_LENGTH>(compiled_dir, "/", info.filename)), Lumix::FS::Mode::READ | Lumix::FS::Mode::OPEN); if (!file) { Lumix::g_log_error.log("Editor") << "Could not open " << info.filename; continue; } char first_line[100]; readLine(file, first_line, sizeof(first_line)); for (int i = 0; i < sizeof(first_line); ++i) { if (first_line[i] == '\0' || first_line[i] == ' ') { first_line[i] = '\0'; break; } } char line[100]; while (readLine(file, line, sizeof(line))) { char* trimmed_line = Lumix::trimmed(line); char* c = trimmed_line; while (*c) { if (*c == ' ') break; ++c; } *c = '\0'; addDependency(trimmed_line, first_line); } char basename[Lumix::MAX_PATH_LENGTH]; char src[Lumix::MAX_PATH_LENGTH]; Lumix::PathUtils::getBasename(basename, sizeof(basename), first_line); getSourceFromBinaryBasename(src, sizeof(src), basename); addDependency(src, first_line); fs.close(*file); } PlatformInterface::destroyFileIterator(iter); }
bool Shader::load(FS::IFile& file) { lua_State* L = luaL_newstate(); luaL_openlibs(L); registerFunctions(this, &m_combintions, &getRenderer(), L); m_render_states = BGFX_STATE_DEPTH_TEST_LEQUAL; bool errors = luaL_loadbuffer(L, (const char*)file.getBuffer(), file.size(), "") != LUA_OK; errors = errors || lua_pcall(L, 0, 0, 0) != LUA_OK; if (errors) { g_log_error.log("Renderer") << getPath().c_str() << ": " << lua_tostring(L, -1); lua_pop(L, 1); return false; } if (!generateInstances()) { g_log_error.log("Renderer") << "Could not load instances of shader " << getPath().c_str(); return false; } m_size = file.size(); lua_close(L); return true; }
void HdrApp::renderMesh(const OpenGLTexture2D &texture, const OpenGLTextureCube &cubeMap) { // Shader to use const OpenGLShader &shader = shaderEffect.at(currentEffect); glActiveTexture(GL_TEXTURE0); texture.bind(); glActiveTexture(GL_TEXTURE1); cubeMap.bind(); shader.begin(); shader.setUniform("env", 1); shader.setUniform("tex", 0); shader.setUniform("reflectionFactor", reflectionFactor); shader.setUniform("fresnelBias", fresnelBias); shader.setUniform("fresnelScale", fresnelScale); shader.setUniform("fresnelPower", fresnelPower); shader.setUniform("etaRatio", etaRatio.x); shader.setUniform("eyePos", cam->getPos()); shader.setUniform("etaRatioRGB", etaRatio); shader.setUniform("matColor", matColor); getRenderer()->renderTriMesh(mesh); OpenGLShader::end(); glActiveTexture(GL_TEXTURE0); }
void HdrApp::renderLoadingScreen() { getRenderer()->clearBuffer(); font.addText(2, screenH-20, Color::WHITE, "<<< LOADING >>>"); font.addText(2, screenH-40, Color::WHITE, loadingString.c_str()); font.render(); }
//----------------------------------------------------------------------- // T G I m a g e //----------------------------------------------------------------------- TGImage::TGImage(TGControl *parent, TGString name, TGString fname, TGString resourceGroup) : TGControl(parent, name) { int x1 = 0, y1 = 0, x2, y2; m_width = 0; m_height = 0; if (!fname.empty()) { if(resourceGroup.empty()) { resourceGroup = Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME.c_str(); } texture = getRenderer()->createTexture(fname,resourceGroup); m_width = texture->getWidth(); m_height = texture->getHeight(); x2 = x1 + (int)m_width - 1; y2 = y1 + (int)m_height - 1; } else { texture = NULL; x2 = x1 + 9; y2 = y1 + 9; } m_brush.bind(new TGBrush(texture)); setBounds(x1, y1, x2, y2); }
ATOM_Button::ATOM_Button (ATOM_Widget *parent, const ATOM_Rect2Di &rect, unsigned style, int id, ATOM_Widget::ShowState showState) : ATOM_Label (parent, rect, (style & ~ATOM_Widget::TitleBar)|ATOM_Widget::Control, id, showState) { ATOM_STACK_TRACE(ATOM_Button::ATOM_Button); ATOM_ASSERT(parent); ATOM_ASSERT(getRenderer()); _mouseOn = false; _mouseEnterAnimator = NULL; _mouseLeaveAnimator = NULL; _currentAnimator = NULL; _clickSound = INVALID_AUDIOID; _hoverSound = INVALID_AUDIOID; setBorderMode (ATOM_Widget::Raise); resize (rect); #if defined(USE_WIDGET_DEBUG_INFO) ATOM_Widget::registerWidgetDebugInfo (this); #endif }
//[-------------------------------------------------------] //[ Public virtual Renderer::IRenderTarget methods ] //[-------------------------------------------------------] void SwapChain::getWidthAndHeight(unsigned int &width, unsigned int &height) const { #ifdef WIN32 // Is there a valid native OS window? if (NULL_HANDLE != mNativeWindowHandle) { // Get the width and height long swapChainWidth = 1; long swapChainHeight = 1; { // Get the client rectangle of the native output window // -> Don't use the width and height stored in "DXGI_SWAP_CHAIN_DESC" -> "DXGI_MODE_DESC" // because it might have been modified in order to avoid zero values RECT rect; ::GetClientRect(reinterpret_cast<HWND>(mNativeWindowHandle), &rect); // Get the width and height... swapChainWidth = rect.right - rect.left; swapChainHeight = rect.bottom - rect.top; // ... and ensure that none of them is ever zero if (swapChainWidth < 1) { swapChainWidth = 1; } if (swapChainHeight < 1) { swapChainHeight = 1; } } // Write out the width and height width = static_cast<UINT>(swapChainWidth); height = static_cast<UINT>(swapChainHeight); } else #elif defined LINUX if (NULL_HANDLE != mNativeWindowHandle) { OpenGLRenderer &openGLRenderer = static_cast<OpenGLRenderer&>(getRenderer()); Display *display = static_cast<const ContextLinux&>(openGLRenderer.getContext()).getDisplay(); ::Window rootWindow = 0; int positionX = 0, positionY = 0; unsigned int unsignedWidth = 0, unsignedHeight = 0, border = 0, depth = 0; XGetGeometry(display, mNativeWindowHandle, &rootWindow, &positionX, &positionY, &unsignedWidth, &unsignedHeight, &border, &depth); width = unsignedWidth; height = unsignedHeight; } else #else #error "Unsupported platform" #endif { // Set known default return values width = 0; height = 0; } }
//----------------------------------------------------------------------- // d r a w //----------------------------------------------------------------------- void TGCursor::draw() { if(!m_isVisible) return; TGRect r(x1,y1,x2,y2); getRenderer()->renderQuadDirect(r,0,m_brush); }
void GameRenderer::setupRender() { // Set the viewport const glm::ivec2& vp = getRenderer()->getViewport(); glViewport(0, 0, vp.x, vp.y); glBindFramebuffer(GL_FRAMEBUFFER, framebufferName); glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT); }
SurfaceImpl *DisplayWGL::createWindowSurface(const egl::SurfaceState &state, const egl::Config *configuration, EGLNativeWindowType window, const egl::AttributeMap &attribs) { EGLint orientation = static_cast<EGLint>(attribs.get(EGL_SURFACE_ORIENTATION_ANGLE, 0)); if (mUseDXGISwapChains) { return new DXGISwapChainWindowSurfaceWGL(state, getRenderer(), window, mD3D11Device, mD3D11DeviceHandle, mWGLContext, mDeviceContext, mFunctionsGL, mFunctionsWGL, orientation); } else { return new WindowSurfaceWGL(state, getRenderer(), window, mPixelFormat, mWGLContext, mFunctionsWGL, orientation); } }
void VideoWidget::performSoftRendering(const QImage ¤tImage) { const int graphIndex = mediaObject()->currentGraph()->index(); VideoRendererSoft *r = static_cast<VideoRendererSoft*>(getRenderer(graphIndex, NonNative, true /*autocreation*/)); r->setSnapshot(currentImage); r->notifyResize(m_widget->size(), m_aspectRatio, m_scaleMode); r->repaintCurrentFrame(m_widget, m_widget->rect()); }
void HdrApp::init(int w, int h) { // Set title setTitle("2006 - UTBM - IN55 - High Dynamic Range in OpenGL - Fabien Houlmann and Stephane Metz"); // Create the camera cam = new Camera(screenW = w, screenH = h, getRenderer()); cam->setPerspective(45.0f, 0.1f, 1000.0f); // Init renderer getRenderer()->setClearColor(Color(0.2f, 0.3f, 0.4f)); // Create the font font.init(w, h); // Mid point cam->setMid(mid = 0.5f); }
bool DisplayWGL::testDeviceLost() { if (mHasARBCreateContextRobustness) { return getRenderer()->getResetStatus() != GL_NO_ERROR; } return false; }
bool ViewData::handleEvent( const eq::EventType type, const seq::KeyEvent& keyEvent ) { switch( type ) { case eq::EVENT_KEY_PRESS: switch( keyEvent.key ) { case ' ': setModelMatrix( _initialModelMatrix ); return true; case 'n': _model->loadNextFrame(); return true; case 'r': setRenderer(serializable::RendererType((int(getRenderer())+1) % (int(serializable::RendererType::OSPRAY)+1))); return true; case 'b': setBlur( !getBlur( )); return true; case '+': setBlurStrength( getBlurStrength() + 0.05f ); return true; case '-': setBlurStrength( getBlurStrength() - 0.05f ); return true; case 'l': { auto& canvas = _view.getConfig()->getCanvases().front(); uint32_t index = canvas->getActiveLayoutIndex() + 1; const auto& layouts = canvas->getLayouts(); index %= layouts.size(); canvas->useLayout( index ); const eq::Layout* layout = layouts[index]; std::ostringstream stream; stream << "Layout "; if( layout ) { const std::string& name = layout->getName(); if( name.empty( )) stream << index; else stream << name; } else stream << "NONE"; stream << " active"; LBINFO << stream.str() << std::endl; return true; } } default: return seq::ViewData::handleEvent( type, keyEvent ); } }
Renderer::IGeometryShader *ShaderLanguageHlsl::createGeometryShaderFromSourceCode(const char *sourceCode, Renderer::GsInputPrimitiveTopology, Renderer::GsOutputPrimitiveTopology, uint32_t, const char *, const char *, const char *) { // Ignore "gsInputPrimitiveTopology", it's directly set within HLSL // Ignore "gsOutputPrimitiveTopology", it's directly set within HLSL // Ignore "numberOfOutputVertices", it's directly set within HLSL // There's no need to check for "Renderer::Capabilities::maximumNumberOfGsOutputVertices", we know there's geometry shader support return new GeometryShaderHlsl(static_cast<Direct3D10Renderer&>(getRenderer()), sourceCode); }
void Rasterizer::pushTriangle(CanvasPortion *canvas, const Vector3 &v1, const Vector3 &v2, const Vector3 &v3) { Vector3 p1, p2, p3; p1 = getRenderer()->projectPoint(v1); p2 = getRenderer()->projectPoint(v2); p3 = getRenderer()->projectPoint(v3); if (pushProjectedTriangle(canvas, p1, p2, p3, v1, v2, v3)) { // Cutting needed Vector3 vm1 = v1.midPointTo(v2); Vector3 vm2 = v2.midPointTo(v3); Vector3 vm3 = v3.midPointTo(v1); pushTriangle(canvas, v1, vm1, vm3); pushTriangle(canvas, v2, vm1, vm2); pushTriangle(canvas, v3, vm3, vm2); pushTriangle(canvas, vm1, vm2, vm3); } }
void ShaderCompiler::compilePass( const char* shd_path, bool is_vertex_shader, const char* pass, int define_mask, const Lumix::ShaderCombinations::Defines& all_defines) { for (int mask = 0; mask < 1 << Lumix::lengthOf(all_defines); ++mask) { if ((mask & (~define_mask)) == 0) { updateNotifications(); char basename[Lumix::MAX_PATH_LENGTH]; Lumix::PathUtils::getBasename(basename, sizeof(basename), shd_path); const char* source_path = StringBuilder<Lumix::MAX_PATH_LENGTH>( "\"shaders/", basename, is_vertex_shader ? "_vs.sc\"" : "_fs.sc\""); char out_path[Lumix::MAX_PATH_LENGTH]; Lumix::copyString(out_path, m_editor.getBasePath()); Lumix::catString(out_path, "/shaders/compiled/"); Lumix::catString(out_path, basename); Lumix::catString(out_path, "_"); Lumix::catString(out_path, StringBuilder<30>(pass, mask)); Lumix::catString(out_path, is_vertex_shader ? "_vs.shb" : "_fs.shb"); StringBuilder<1024> args(" -f "); args << source_path << " -o \"" << out_path << "\" --depends --platform windows --type " << (is_vertex_shader ? "vertex --profile vs_4_0" : "fragment --profile ps_4_0") << " -D " << pass; for (int i = 0; i < Lumix::lengthOf(all_defines); ++i) { if (mask & (1 << i)) { args << " -D " << getRenderer().getShaderDefine(all_defines[i]); } } StringBuilder<Lumix::MAX_PATH_LENGTH> cmd(m_editor.getBasePath(), "/shaders/shaderc.exe"); Lumix::deleteFile(out_path); auto* process = Lumix::createProcess(cmd, args, m_editor.getAllocator()); if (!process) { Lumix::g_log_error.log("shader compiler") << "Could not execute command: " << cmd; } else { auto& p = m_processes.pushEmpty(); p.process = process; Lumix::copyString(p.path, out_path); } } } }
//---------------------------------------- ofRectangle ofEasyCam::getControlArea() const { if (controlArea.isZero()) { if (viewport.isZero()) { return getRenderer()->getCurrentViewport(); } return viewport; } return controlArea; }
void VertexBuffer::onDraw() { // Get and check the renderer instance Renderer::IRendererPtr renderer(getRenderer()); if (nullptr != renderer) { // Submit command buffer to the renderer backend mCommandBuffer.submitToRenderer(*renderer); } }
void FreesteelWindow::showAll() { I1 xrg(1000,-1000), yrg(1000,-1000), zrg(1000,-1000); for (size_t i = 0; i < gstees.size(); ++i) { xrg.Absorb(gstees[i]->xrg, i == 0); yrg.Absorb(gstees[i]->yrg, i == 0); zrg.Absorb(gstees[i]->zrg, i == 0); } getRenderer()->GetActiveCamera()->SetFocalPoint(xrg.Half(), yrg.Half(), zrg.Half()); getRenderer()->GetActiveCamera()->SetPosition(xrg.Half(), yrg.Half(), zrg.hi + 100); // scale to fill window ASSERT(getRenderer()->GetActiveCamera()->GetParallelProjection() != 0); double scale = getRenderer()->GetActiveCamera()->GetParallelScale(); getRenderer()->GetActiveCamera()->SetParallelScale(max(xrg.Leng(), yrg.Leng())); }
void GameLevel::createHero(const cocos2d::Vec2 &pos) { Parameter param; param.set(PARAM_BLOCK_KIND, KIND_HERO) .set(PARAM_POS, pos) .set(PARAM_SIZE, Size(GameConfig::instance().HeroSize, GameConfig::instance().HeroSize)); auto hero = getObjectManager()->createObject(param); hero->getRenderer()->setShadowLayer(1); CC_ASSERT(hero->getID() == 0); }
void VideoWidget::setCurrentGraph(int index) { for(int i = 0; i < 2; ++i) { if (AbstractVideoRenderer *renderer = getRenderer(i, Native)) renderer->setActive(index == i); } //be sure to update all the things that needs an update applyMixerSettings(); updateVideoSize(); AbstractVideoRenderer *r = m_widget->currentRenderer(); //we determine dynamically if it is native or non native r = getRenderer(index, !r || r->isNative() ? Native : NonNative); if (!r) r = getRenderer(index, NonNative); m_widget->setCurrentRenderer(r); }
void FirstGeometryShader::onDraw() { // Get and check the renderer instance Renderer::IRendererPtr renderer(getRenderer()); if (nullptr != renderer) { // Submit command buffer to the renderer backend mCommandBuffer.submit(*renderer); } }
SurfaceImpl *DisplayGLX::createWindowSurface(const egl::SurfaceState &state, EGLNativeWindowType window, const egl::AttributeMap &attribs) { ASSERT(configIdToGLXConfig.count(state.config->configID) > 0); glx::FBConfig fbConfig = configIdToGLXConfig[state.config->configID]; return new WindowSurfaceGLX(state, mGLX, this, getRenderer(), window, mGLX.getDisplay(), fbConfig); }
void drawPlayer(void) { /* Gestion du timer */ /* Si notre timer (un compte à rebours en fait) arrive à zéro */ if(player.state <= WALK_DOWN) walkFrameTimer(); else attackFrameTimer(); /* Ensuite, on peut passer la main à notre fonction */ /* Rectangle de destination à dessiner */ SDL_Rect dest; /* On soustrait des coordonnées de notre héros, ceux du début de la map, pour qu'il colle au scrolling : */ dest.x = player.x - getStartX(); dest.y = player.y - getStartY(); dest.w = player.w; dest.h = player.h; /* Rectangle source */ SDL_Rect src; /* Pour connaître le X de la bonne frame à dessiner, il suffit de multiplier la largeur du sprite par le numéro de la frame à afficher -> 0 = 0; 1 = 40; 2 = 80... */ src.x = player.frameNumber * player.w; src.w = player.w; src.h = player.h; /* On calcule le Y de la bonne frame à dessiner, selon la valeur de l'état du héros : Aucun mouvement (Idle) = 0, marche (walk) = 1, etc... Tout cela en accord avec notre spritesheet, of course ;) */ src.y = player.state * player.h; /* Si on a été touché, et qu'on est invincible */ int q; if(player.invincibleTimer > 0) q = 2; else q = 1; /* On fait clignoter le héros une frame sur deux; Pour ça, on calcule si le numéro de la frame est un multiple de deux */ if(player.frameNumber % q == 0) { /* Gestion du flip (retournement de l'image selon que le sprite regarde à droite ou à gauche */ const SDL_RendererFlip flip = player.direction == LEFT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE; SDL_RenderCopyEx(getRenderer(), playerSpriteSheet, &src, &dest, 0, 0, flip); } }
bool ModelViewApp::initialize() { if (!BaseApp::initialize()) return false; spank::IRenderer* pRenderer = getRenderer(); m_pMeshData = getFramework()->getModelMgr()->createMeshData("data/md5/Bob.mesh"); if (!m_pMeshData) return false; return true; }