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;
}
