use of org.lwjgl.opengl.GL30.glGetInteger in project legui by SpinyOwl.
the class FBOImageExample method main.
public static void main(String[] args) throws IOException {
System.setProperty("joml.nounsafe", Boolean.TRUE.toString());
System.setProperty("java.awt.headless", Boolean.TRUE.toString());
if (!GLFW.glfwInit()) {
throw new RuntimeException("Can't initialize GLFW");
}
long window = glfwCreateWindow(WIDTH, HEIGHT, "FBO Image example", NULL, NULL);
glfwShowWindow(window);
glfwMakeContextCurrent(window);
GL.createCapabilities();
glfwSwapInterval(0);
// Firstly we need to create frame component for window.
Frame frame = new Frame(WIDTH, HEIGHT);
// We need to create legui context which shared by renderer and event processor.
// Also we need to pass event processor for ui events such as click on component, key typing and etc.
Context context = new Context(window);
// We need to create callback keeper which will hold all of callbacks.
// These callbacks will be used in initialization of system event processor
// (will be added callbacks which will push system events to event queue and after that processed by SystemEventProcessor)
CallbackKeeper keeper = new DefaultCallbackKeeper();
// register callbacks for window. Note: all previously binded callbacks will be unbinded.
CallbackKeeper.registerCallbacks(window, keeper);
GLFWKeyCallbackI glfwKeyCallbackI = (w1, key, code, action, mods) -> running = !(key == GLFW_KEY_ESCAPE && action != GLFW_RELEASE);
GLFWWindowCloseCallbackI glfwWindowCloseCallbackI = w -> running = false;
// if we want to create some callbacks for system events you should create and put them to keeper
//
// Wrong:
// glfwSetKeyCallback(window, glfwKeyCallbackI);
// glfwSetWindowCloseCallback(window, glfwWindowCloseCallbackI);
//
// Right:
keeper.getChainKeyCallback().add(glfwKeyCallbackI);
keeper.getChainWindowCloseCallback().add(glfwWindowCloseCallbackI);
// Event processor for system events. System events should be processed and translated to gui events.
SystemEventProcessor systemEventProcessor = new SystemEventProcessorImpl();
SystemEventProcessor.addDefaultCallbacks(keeper, systemEventProcessor);
// Also we need to create renderer provider
// and create renderer which will render our ui components.
Renderer renderer = new NvgRenderer();
// Initialization finished, so we can start render loop.
running = true;
// Everything can be done in one thread as well as in separated threads.
// Here is one-thread example.
// before render loop we need to initialize renderer
renderer.initialize();
// //// rendering to texture and use this texture as image
long nvgContext = 0;
FBOImage fboTexture = null;
boolean isVersionNew = (glGetInteger(GL_MAJOR_VERSION) > 3) || (glGetInteger(GL_MAJOR_VERSION) == 3 && glGetInteger(GL_MINOR_VERSION) >= 2);
if (isVersionNew) {
int flags = NanoVGGL3.NVG_STENCIL_STROKES | NanoVGGL3.NVG_ANTIALIAS;
nvgContext = NanoVGGL3.nvgCreate(flags);
} else {
int flags = NanoVGGL2.NVG_STENCIL_STROKES | NanoVGGL2.NVG_ANTIALIAS;
nvgContext = NanoVGGL2.nvgCreate(flags);
}
if (nvgContext != 0) {
fboTexture = createFBOTexture(textureWidth, textureHeight);
Widget widget = new Widget(10, 10, 100, 100);
widget.setCloseable(false);
widget.setMinimizable(false);
widget.setResizable(true);
widget.getContainer().getStyle().setDisplay(DisplayType.FLEX);
ImageView imageView = new ImageView(fboTexture);
imageView.setPosition(10, 10);
imageView.getStyle().setPosition(PositionType.RELATIVE);
imageView.getStyle().getFlexStyle().setFlexGrow(1);
imageView.getStyle().setMargin(10f);
imageView.getStyle().setMinimumSize(50, 50);
widget.getContainer().add(imageView);
frame.getContainer().add(widget);
}
while (running) {
if (fboTexture != null) {
renderToFBO(nvgContext);
}
// Before rendering we need to update context with window size and window framebuffer size
// {
// int[] windowWidth = {0}, windowHeight = {0};
// GLFW.glfwGetWindowSize(window, windowWidth, windowHeight);
// int[] frameBufferWidth = {0}, frameBufferHeight = {0};
// GLFW.glfwGetFramebufferSize(window, frameBufferWidth, frameBufferHeight);
// int[] xpos = {0}, ypos = {0};
// GLFW.glfwGetWindowPos(window, xpos, ypos);
// double[] mx = {0}, my = {0};
// GLFW.glfwGetCursorPos(window, mx, my);
//
// context.update(windowWidth[0], windowHeight[0],
// frameBufferWidth[0], frameBufferHeight[0],
// xpos[0], ypos[0],
// mx[0], my[0]
// );
// }
// Also we can do it in one line
context.updateGlfwWindow();
Vector2i windowSize = context.getFramebufferSize();
glClearColor(1, 1, 1, 1);
// Set viewport size
glViewport(0, 0, windowSize.x, windowSize.y);
// Clear screen
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
// render frame
renderer.render(frame, context);
// poll events to callbacks
glfwPollEvents();
glfwSwapBuffers(window);
// Now we need to process events. Firstly we need to process system events.
systemEventProcessor.processEvents(frame, context);
// When system events are translated to GUI events we need to process them.
// This event processor calls listeners added to ui components
EventProcessorProvider.getInstance().processEvents();
// When everything done we need to relayout components.
LayoutManager.getInstance().layout(frame);
// Run animations. Should be also called cause some components use animations for updating state.
AnimatorProvider.getAnimator().runAnimations();
}
if (nvgContext != 0) {
glDeleteRenderbuffers(renderBufferID);
glDeleteTextures(textureID);
glDeleteFramebuffers(frameBufferID);
if (isVersionNew) {
NanoVGGL3.nnvgDelete(nvgContext);
} else {
NanoVGGL2.nnvgDelete(nvgContext);
}
}
// And when rendering is ended we need to destroy renderer
renderer.destroy();
glfwDestroyWindow(window);
glfwTerminate();
}
use of org.lwjgl.opengl.GL30.glGetInteger in project gaiasky by langurmonkey.
the class GaiaSky method create.
@Override
public void create() {
startTime = TimeUtils.millis();
// Log level
Gdx.app.setLogLevel(debugMode ? Application.LOG_DEBUG : Application.LOG_INFO);
Logger.level = debugMode ? Logger.LoggerLevel.DEBUG : Logger.LoggerLevel.INFO;
consoleLogger = new ConsoleLogger();
if (debugMode)
logger.debug("Logging level set to DEBUG");
// Init graphics and window
graphics = Gdx.graphics;
window = headless ? null : ((Lwjgl3Graphics) graphics).getWindow();
// Basic info
logger.info(settings.version.version, I18n.txt("gui.build", settings.version.build));
logger.info("Display mode", graphics.getWidth() + "x" + graphics.getHeight(), "Fullscreen: " + Gdx.graphics.isFullscreen());
logger.info("Device", GL30.glGetString(GL30.GL_RENDERER));
logger.info(I18n.txt("notif.glversion", GL30.glGetString(GL30.GL_VERSION)));
logger.info(I18n.txt("notif.glslversion", GL30.glGetString(GL30.GL_SHADING_LANGUAGE_VERSION)));
logger.info(I18n.txt("notif.javaversion", System.getProperty("java.version"), System.getProperty("java.vendor")));
// Frame buffer map
frameBufferMap = new HashMap<>();
// Disable all kinds of input
EventManager.publish(Event.INPUT_ENABLED_CMD, this, false);
if (!settings.initialized) {
logger.error(new RuntimeException(I18n.txt("notif.error", "global configuration not initialized")));
return;
}
// Initialise times
final ITimeFrameProvider clock = new GlobalClock(1, Instant.now());
final ITimeFrameProvider real = new RealTimeClock();
time = settings.runtime.realTime ? real : clock;
t = 0;
// Initialise i18n
I18n.initialize();
// Tooltips
TooltipManager.getInstance().initialTime = 1f;
TooltipManager.getInstance().hideAll();
// Initialise asset manager
final FileHandleResolver internalResolver = new InternalFileHandleResolver();
final FileHandleResolver dataResolver = fileName -> settings.data.dataFileHandle(fileName);
assetManager = new AssetManager(internalResolver);
assetManager.setLoader(com.badlogic.gdx.graphics.Texture.class, ".pfm", new PFMTextureLoader(dataResolver));
assetManager.setLoader(PFMData.class, new PFMDataLoader(dataResolver));
assetManager.setLoader(ISceneGraph.class, new SGLoader(dataResolver));
assetManager.setLoader(PointCloudData.class, new OrbitDataLoader(dataResolver));
assetManager.setLoader(GaiaAttitudeServer.class, new GaiaAttitudeLoader(dataResolver));
assetManager.setLoader(ExtShaderProgram.class, new ShaderProgramProvider(internalResolver, ".vertex.glsl", ".fragment.glsl"));
assetManager.setLoader(BitmapFont.class, new BitmapFontLoader(internalResolver));
assetManager.setLoader(AtmosphereShaderProvider.class, new AtmosphereShaderProviderLoader<>(internalResolver));
assetManager.setLoader(GroundShaderProvider.class, new GroundShaderProviderLoader<>(internalResolver));
assetManager.setLoader(TessellationShaderProvider.class, new TessellationShaderProviderLoader<>(internalResolver));
assetManager.setLoader(RelativisticShaderProvider.class, new RelativisticShaderProviderLoader<>(internalResolver));
assetManager.setLoader(IntModel.class, ".obj", new OwnObjLoader(new RegularInputStreamProvider(), internalResolver));
assetManager.setLoader(IntModel.class, ".obj.gz", new OwnObjLoader(new GzipInputStreamProvider(), internalResolver));
assetManager.setLoader(IntModel.class, ".g3dj", new G3dModelLoader(new JsonReader(), internalResolver));
assetManager.setLoader(IntModel.class, ".g3db", new G3dModelLoader(new UBJsonReader(), internalResolver));
// Remove Model loaders
// Init global resources
this.globalResources = new GlobalResources(assetManager);
// Initialize screenshots manager
new ScreenshotsManager(globalResources);
// Catalog manager
this.catalogManager = new CatalogManager();
this.scripting = new EventScriptingInterface(this.assetManager, this.catalogManager);
// Initialise master manager
MasterManager.initialize();
// Load slave assets
SlaveManager.load(assetManager);
// Initialise dataset updater
this.executorService = new GaiaSkyExecutorService();
// Bookmarks
this.bookmarksManager = new BookmarksManager();
// Location log
LocationLogManager.initialize();
// Init timer thread
Timer.instance();
// Initialise Cameras
cameraManager = new CameraManager(assetManager, CameraMode.FOCUS_MODE, vr, globalResources);
// Set asset manager to asset bean
AssetBean.setAssetManager(assetManager);
// Create vr context if possible
final VRStatus vrStatus = createVR();
cameraManager.updateFrustumPlanes();
// Tooltip to 1s
TooltipManager.getInstance().initialTime = 1f;
// Initialise Gaia attitudes
assetManager.load(Constants.ATTITUDE_FOLDER, GaiaAttitudeServer.class, new GaiaAttitudeLoaderParameter());
// Initialise hidden helper user
HiddenHelperUser.initialize();
// Initialise gravitational waves helper
RelativisticEffectsManager.initialize(time);
// GUI
guis = new ArrayList<>(3);
// Post-processor
postProcessor = PostProcessorFactory.instance.getPostProcessor();
// Scene graph renderer
sgr = new SceneGraphRenderer(vrContext, globalResources);
sgr.initialize(assetManager);
// Initialise scripting gateway server
if (!noScripting)
ScriptingServer.initialize();
// Tell the asset manager to load all the assets
final Set<AssetBean> assets = AssetBean.getAssets();
for (AssetBean ab : assets) {
ab.load(assetManager);
}
renderBatch = globalResources.getSpriteBatch();
EventManager.instance.subscribe(this, Event.LOAD_DATA_CMD);
welcomeGui = new WelcomeGui(globalResources.getSkin(), graphics, 1f / settings.program.ui.scale, skipWelcome, vrStatus);
welcomeGui.initialize(assetManager, globalResources.getSpriteBatch());
Gdx.input.setInputProcessor(welcomeGui.getGuiStage());
if (settings.runtime.openVr) {
welcomeGuiVR = new VRGui<>(WelcomeGuiVR.class, (int) (settings.graphics.backBufferResolution[0] / 2f), globalResources.getSkin(), graphics, 1f / settings.program.ui.scale);
welcomeGuiVR.initialize(assetManager, globalResources.getSpriteBatch());
}
// GL clear state
Gdx.gl.glClearColor(0, 0, 0, 0);
Gdx.gl.glClearDepthf(1f);
}
Aggregations