TextRenderer::TextRenderer(Shader* shader, std::string fontName)
{
this->shader = shader;
// Gen bitmaps for all these sizes
initRenderer(fontName, _12PX, chars12px);
initRenderer(fontName, _14PX, chars14px);
initRenderer(fontName, _16PX, chars16px);
initRenderer(fontName, _18PX, chars18px);
// gen vao
genDynamicVAO();
}
MSAEditorConsensusArea::MSAEditorConsensusArea(MsaEditorWgt *ui)
: MaEditorConsensusArea(ui) {
initCache();
initRenderer();
setupFontAndHeight();
connect(editor, SIGNAL(si_buildStaticMenu(GObjectView *, QMenu *)), SLOT(sl_buildStaticMenu(GObjectView *, QMenu *)));
connect(editor, SIGNAL(si_buildPopupMenu(GObjectView * , QMenu *)), SLOT(sl_buildContextMenu(GObjectView *, QMenu *)));
}
Board::Board(const std::vector<int>& probes, int width, int height) :
mProbes(probes),
width(width),
height(height),
mSelected0(nullptr),
mSelected1(nullptr),
mBlockInput(false)
{
//Initialize the components
initRenderer();
mAnimationManager.setMoveStep(SWAP_DIFF_STEP);
};
bool Widget::init()
{
if (ProtectedNode::init())
{
initRenderer();
setBright(true);
ignoreContentAdaptWithSize(true);
setAnchorPoint(Vec2(0.5f, 0.5f));
return true;
}
return false;
}
HRESULT Raytracer::init( HINSTANCE p_hInstance, int p_cmdShow )
{
HRESULT hr = S_OK;
hr = initWindow( p_hInstance, p_cmdShow );
if(SUCCEEDED(hr))
hr = initRenderer();
if(SUCCEEDED(hr))
initCamera();
return hr;
}
void SurvivalMode::setup() {
_window = initWindow(_windowRef);
if (!_window) {
printErrorMessage("SurvivalMode", "Window");
}
_renderer = initRenderer(_window, _rendererRef);
if (!_renderer) {
printErrorMessage("SurvivalMode", "Renderer");
}
_running = true;
}
void setupDisplay(gDisplay *d) {
fprintf(stderr, "trying to create window\n");
d->win_id = initWindow();
fprintf(stderr, "window created\n");
initRenderer();
printRendererInfo();
/* printf("win_id is %d\n", d->win_id); */
fprintf(stderr, "loading art\n");
loadArt();
// initBitmaps(game->screen);
SystemReshapeFunc(reshape);
}
void GameplayModeScene::setup() {
_window = initWindow(_windowRef);
if (!_window) {
printErrorMessage("GameplayModeScene", "Window");
}
_renderer = initRenderer(_window, _rendererRef);
if (!_renderer) {
printErrorMessage("GameplayModeScene", "Renderer");
}
_running = true;
}
void Renderinstance::testinitRenderer(
const UsedRenderer usedrenderer,
const Windowmode windowmode,
const int windowwidth,
const int windowheight,
const bool interactive)
{
if (m_pRenderer!=0) return;
if (m_pTestscene==0) m_pTestscene=video::generateTestscene(0,0);
initRenderer(usedrenderer,windowmode,windowwidth,windowheight,interactive);
scene(*m_pTestscene);
}
bool Widget::init()
{
if (Node::init())
{
initRenderer();
setCascadeColorEnabled(true);
setCascadeOpacityEnabled(true);
setBright(true);
ignoreContentAdaptWithSize(true);
setAnchorPoint(Point(0.5f, 0.5f));
return true;
}
return false;
}
bool Widget::init()
{
if (ProtectedNode::init())
{
initRenderer();
setBright(true);
onFocusChanged = CC_CALLBACK_2(Widget::onFocusChange,this);
onNextFocusedWidget = nullptr;
this->setAnchorPoint(Vec2(0.5f, 0.5f));
ignoreContentAdaptWithSize(true);
return true;
}
return false;
}
bool UIWidget::init()
{
m_children = CCArray::create();
m_children->retain();
initRenderer();
m_pRenderer->retain();
m_pRenderer->setZOrder(m_nWidgetZOrder);
CCRGBAProtocol* renderRGBA = DYNAMIC_CAST_CCRGBAPROTOCOL;
if (renderRGBA)
{
renderRGBA->setCascadeColorEnabled(true);
renderRGBA->setCascadeOpacityEnabled(true);
}
setBright(true);
ignoreContentAdaptWithSize(true);
return true;
}
bool Widget::init()
{
if (CCNode::init())
{
_widgetChildren = CCArray::create();
CC_SAFE_RETAIN(_widgetChildren);
_layoutParameterDictionary = CCDictionary::create();
CC_SAFE_RETAIN(_layoutParameterDictionary);
_nodes = CCArray::create();
CC_SAFE_RETAIN(_nodes);
initRenderer();
setBright(true);
setAnchorPoint(CCPoint(0.5f, 0.5f));
return true;
}
return false;
}
bool Layout::init()
{
if (CCNode::init())
{
_widgetChildren = CCArray::create();
CC_SAFE_RETAIN(_widgetChildren);
_layoutParameterDictionary = CCDictionary::create();
CC_SAFE_RETAIN(_layoutParameterDictionary);
_nodes = CCArray::create();
CC_SAFE_RETAIN(_nodes);
initRenderer();
setBright(true);
ignoreContentAdaptWithSize(false);
setSize(CCSizeZero);
setAnchorPoint(CCPointZero);
return true;
}
return false;
}
bool Widget::init()
{
if (CCNodeRGBA::init())
{
_widgetChildren = CCArray::create();
CC_SAFE_RETAIN(_widgetChildren);
_layoutParameterDictionary = CCDictionary::create();
CC_SAFE_RETAIN(_layoutParameterDictionary);
_nodes = CCArray::create();
CC_SAFE_RETAIN(_nodes);
initRenderer();
setCascadeColorEnabled(true);
setCascadeOpacityEnabled(true);
setBright(true);
ignoreContentAdaptWithSize(true);
setAnchorPoint(CCPoint(0.5f, 0.5f));
return true;
}
return false;
}
bool Layout::init()
{
m_children = CCArray::create();
m_children->retain();
initRenderer();
m_pRenderer->retain();
m_pRenderer->setZOrder(m_nWidgetZOrder);
CCRGBAProtocol* renderRGBA = dynamic_cast<CCRGBAProtocol*>(m_pRenderer);
if (renderRGBA)
{
renderRGBA->setCascadeColorEnabled(false);
renderRGBA->setCascadeOpacityEnabled(false);
}
ignoreContentAdaptWithSize(false);
setSize(CCSizeZero);
setBright(true);
setAnchorPoint(ccp(0, 0));
m_pScheduler = CCDirector::sharedDirector()->getScheduler();
CC_SAFE_RETAIN(m_pScheduler);
return true;
}
bool UIWidget::init()
{
m_children = CCArray::create();
m_children->retain();
m_pLayoutParameterDictionary = CCDictionary::create();
CC_SAFE_RETAIN(m_pLayoutParameterDictionary);
initRenderer();
m_pRenderer->retain();
m_pRenderer->setZOrder(m_nWidgetZOrder);
CCRGBAProtocol* renderRGBA = DYNAMIC_CAST_CCRGBAPROTOCOL;
if (renderRGBA)
{
renderRGBA->setCascadeColorEnabled(true);
renderRGBA->setCascadeOpacityEnabled(true);
}
setBright(true);
ignoreContentAdaptWithSize(true);
m_pScheduler = CCDirector::sharedDirector()->getScheduler();
CC_SAFE_RETAIN(m_pScheduler);
return true;
}
int RTRDemo::init(const std::string& configFile)
{
// Init log file
std::string logFile = "log/" + createTimeStamp() + ".log";
if (!CLogger::initLogFile(logFile))
{
LOG_WARNING("Failed to create log file at %s.", logFile.c_str());
}
m_debugInfo = std::make_shared<CDebugInfo>();
CLogger::addListener(m_debugInfo.get());
if (!m_config.load(configFile))
{
LOG_WARNING("Failed to load config file %s, starting with default settings.",
configFile.c_str());
}
// Create window for rendering
if (!initWindow())
{
LOG_ERROR("Failed to initialize window.");
return 1;
}
m_inputProvider = std::make_shared<CGlfwInputProvider>(m_window->getGlfwHandle());
// Create resource manager
m_resourceManager.reset(createResourceManager());
if (m_resourceManager == nullptr)
{
LOG_ERROR("Failed to initialize resource manager.");
return 1;
}
// Create animation world
m_animationWorld = std::make_shared<CAnimationWorld>();
// Graphics resource manager, listens to resource manager
CGraphicsResourceManager* manager = new CGraphicsResourceManager;
m_resourceManager->addResourceListener(manager);
m_graphicsResourceManager.reset(manager);
// Create renderer
if (!initRenderer())
{
LOG_ERROR("Failed to initialize renderer.");
return 1;
}
if (!initScene())
{
LOG_ERROR("Failed to initialize scene.");
return 1;
}
m_camera = std::make_shared<CFirstPersonCamera>(
glm::vec3(0.5f, 0.f, 0.5f), glm::vec3(0.f, 0.f, 1.f), glm::vec3(0.f, 1.f, 0.f), 45.f,
4.f / 3.f, 0.01f, 1000.f);
m_cameraController = std::make_shared<CCameraController>();
m_cameraController->setCamera(m_camera);
m_cameraController->setInputProvider(m_inputProvider.get());
m_debugInfoDisplay = std::make_shared<CDebugInfoDisplay>(m_resourceManager);
m_window->addListener(m_cameraController.get());
return 0;
}
pcl::modeler::RenderWidget::RenderWidget(MainWindow* main_window, size_t id, QWidget *parent, Qt::WFlags flags) :
QVTKWidget(parent, flags), main_window_(main_window), active_(false), id_(id)
{
setFocusPolicy(Qt::StrongFocus);
initRenderer();
}
int SDLFrontend::init (int width, int height, bool fullscreen, EventHandler &eventHandler)
{
if (width == -1 && height == -1)
fullscreen = true;
info(LOG_CLIENT,
String::format("initializing: %i:%i - fullscreen: %s", width, height, fullscreen ? "true" : "false"));
INIT_Subsystem(SDL_INIT_VIDEO, true);
INIT_Subsystem(SDL_INIT_JOYSTICK, false);
INIT_Subsystem(SDL_INIT_GAMECONTROLLER, false);
INIT_Subsystem(SDL_INIT_HAPTIC, false);
initJoystickAndHaptic();
SDL_DisplayMode displayMode;
SDL_GetDesktopDisplayMode(0, &displayMode);
const char *name = SDL_GetPixelFormatName(displayMode.format);
info(LOG_CLIENT, String::format("current desktop mode: %dx%d@%dHz (%s)",
displayMode.w, displayMode.h, displayMode.refresh_rate, name));
if (width == -1)
width = 800;//displayMode.w;
if (height == -1)
height = 480; //displayMode.h;
setGLAttributes();
setHints();
int doubleBuffered = 0;
SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &doubleBuffered);
info(LOG_CLIENT, String::format("doublebuffer: %s", doubleBuffered ? "activated" : "disabled"));
int flags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;
#ifdef __IPHONEOS__
flags |= SDL_WINDOW_RESIZABLE;
#endif
#if 1 //defined __IPHONEOS__ || defined __ANDROID__
if (fullscreen)
flags |= SDL_WINDOW_FULLSCREEN | SDL_WINDOW_BORDERLESS;
#else
if (fullscreen)
flags |= SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_BORDERLESS;
#endif
const int videoDrivers = SDL_GetNumVideoDrivers();
for (int i = 0; i < videoDrivers; ++i) {
info(LOG_CLIENT, String::format("available driver: %s", SDL_GetVideoDriver(i)));
}
info(LOG_CLIENT, String::format("driver: %s", SDL_GetCurrentVideoDriver()));
const int displays = SDL_GetNumVideoDisplays();
info(LOG_CLIENT, String::format("found %i display(s)", displays));
if (fullscreen && displays > 1) {
width = displayMode.w;
height = displayMode.h;
info(LOG_CLIENT, String::format("use fake fullscreen for the first display: %i:%i", width, height));
}
_window = SDL_CreateWindow(Singleton<Application>::getInstance().getName().c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, flags);
if (!_window) {
sdlCheckError();
return -1;
}
SDL_DisableScreenSaver();
initRenderer();
resetColor();
GLContext::get().init();
if (SDL_SetWindowBrightness(_window, 1.0f) == -1)
sdlCheckError();
if (Config.isGrabMouse() && (!fullscreen || displays > 1)) {
SDL_SetWindowGrab(_window, SDL_TRUE);
}
int screen = 0;
int modes = SDL_GetNumDisplayModes(screen);
info(LOG_CLIENT, "possible display modes:");
for (int i = 0; i < modes; i++) {
SDL_GetDisplayMode(screen, i, &displayMode);
name = SDL_GetPixelFormatName(displayMode.format);
info(LOG_CLIENT, String::format("%dx%d@%dHz %s",
displayMode.w, displayMode.h, displayMode.refresh_rate, name));
}
// some platforms may override or hardcode the resolution - so
// we have to query it here to get the actual resolution
SDL_GetWindowSize(_window, &width, &height);
if (SDL_SetRelativeMouseMode(SDL_TRUE) == -1)
error(LOG_CLIENT, "no relative mouse mode support");
SDL_ShowCursor(0);
info(LOG_CLIENT, String::format("actual resolution: %dx%d", width, height));
setVSync(ConfigManager::get().isVSync());
const int initState = IMG_Init(IMG_INIT_PNG);
if (!(initState & IMG_INIT_PNG)) {
sdlCheckError();
System.exit("No png support", 1);
}
_width = width;
_height = height;
updateViewport(0, 0, getWidth(), getHeight());
onInit();
_eventHandler = &eventHandler;
_eventHandler->registerObserver(_console.get());
_eventHandler->registerObserver(this);
info(LOG_CLIENT, "init the shader manager");
ShaderManager::get().init();
if (!Config.isSoundEnabled()) {
info(LOG_CLIENT, "sound disabled");
} else if (!SoundControl.init(true)) {
error(LOG_CLIENT, "sound initialization failed");
}
return 0;
}
int main(int argc, char* argv[])
{
log_data = new Log(); // ugh
SDL_Window* window = 0;
SDL_GLContext gl = 0;
int win_w;
int win_h;
if(initGL(&window, &gl, &win_w, &win_h) == 1) return 1;
GLuint gl_depth_buff_id;
GLuint gl_framebuffer_id;
blit_renderer br; initBlitRenderer(&br);
renderer r; initRenderer(&r);
glGenRenderbuffers(1, &gl_depth_buff_id);
glBindRenderbuffer(GL_RENDERBUFFER, gl_depth_buff_id);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, br.texture_width, br.texture_height);
glGenFramebuffers(1, &gl_framebuffer_id);
glBindFramebuffer(GL_FRAMEBUFFER, gl_framebuffer_id);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, br.gl_texture_buff_id, 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, gl_depth_buff_id);
Uint8 done = 0;
SDL_Event event;
while(!done)
{
while(SDL_PollEvent(&event))
{
if(
false
|| event.type == SDL_QUIT
|| event.type == SDL_KEYDOWN
#if DO_PLATFORM == DO_PLATFORM_ANDROID
|| event.type == SDL_FINGERDOWN
#endif
)
{
done = 1;
}
}
updateRenderer(&r);
//draw into FB
glBindFramebuffer(GL_FRAMEBUFFER, gl_framebuffer_id);
renderRenderer(&r,br.texture_width,br.texture_height);
//blit FB
glBindFramebuffer(GL_FRAMEBUFFER, 0);
renderBlitRenderer(&br,win_w,win_h);
SDL_GL_SwapWindow(window);
SDL_Delay(10);
}
SDL_GL_DeleteContext(gl);
IMG_Quit();
SDL_Quit();
exit(0);
return 0;
}
vkeGameRendererDynamic::vkeGameRendererDynamic() :
VkeRenderer(), m_node_data(NULL)
{
initRenderer();
}
void setup(){
initRenderer();
setupRenderer();
trackball (qCamera, 0, 0, 0, 0); // qCameraOld[3] = 1.0;
lists = new ListKeeper( 16 );
/*
int ifree = lists->getFree();
int igl=glGenLists(1);
glNewList( igl , GL_COMPILE);
//drawLines( nlinks, links, (Vec3d*) points );
drawBox( -0.5, +0.5, -0.5, +0.5, -0.5, +0.5, 0.5, 0.8, 0.5 );
glEndList();
lists->data[ ifree ] = igl;
*/
/*
int ndiv = 5;
Vec3d pos; pos.set(0,0,0);
int ifree = lists->getFree();
int igl=glGenLists(1);
glNewList( igl , GL_COMPILE);
glShadeModel ( GL_SMOOTH );
int nvert = drawSphere_oct( ndiv, 2.5, pos );
glEndList();
lists->data[ ifree ] = igl;
printf( " sphere %i nvert %i \n", ndiv, nvert );
*/
//Vec3f tip; tip.set(3.00,0,0);
//Vec3f base; base.set(0,0.0,0.0);
/*
Vec3f tip; tip.set (0.000,0.00,0.00);
Vec3f base; base.set(1.0,2.0,3.0);
int ndiv = 16;
Vec3d pos; pos.set(0,0,0);
int ifree = lists->getFree();
int igl=glGenLists(1);
glNewList( igl , GL_COMPILE);
glShadeModel ( GL_SMOOTH );
//int nvert = drawConeFan( ndiv, 0.5, base, tip );
int nvert = drawCylinderStrip( ndiv, 0.5, 1.0, base, tip );
glEndList();
lists->data[ ifree ] = igl;
printf( " sphere %i nvert %i \n", ndiv, nvert );
*/
int npoints,nbonds;
int * bonds;
int * bondTypes;
Vec3d * points;
int ndiv = 16;
Vec3d dir,side,up;
dir .set( 1,0,0 );
side.set( 0,0,1 );
up .set( 0,1,0 );
makeGirder_Type1( ndiv, 32.0, 1.0, dir,side,up, npoints, nbonds, points, bonds, bondTypes);
int ifree = lists->getFree();
int igl=glGenLists(1);
glNewList( igl , GL_COMPILE);
int nvert = drawGirder( npoints, nbonds, points, bonds, bondTypes );
glEndList();
lists->data[ ifree ] = igl;
printf( " girder ndiv = %i nvert %i \n", ndiv, nvert );
bondTypeBook = new BondTypes( def_nBondTypes, def_bondTypes_area, def_bondTypes_material );
truss = new SoftBody( npoints, nbonds, 4, points, NULL, NULL, bonds, bondTypes, *bondTypeBook, &def_fix[0] );
//colors= &colors_def[0];
//radii = &radii_def [0];
}
