Tag Info

New answers tagged

0

My guess is that this is one way to provide older machines with a way to improve performance by rendering less graphics and just stretching them across the screen, but surely there are better ways of improving performance (choosing different texture and model qualities, for example). That's not so simple. A game can run slow on my machine because it's ...


2

Additional reason: Changing environments. 1080 is now standard, but wasn't 5 years ago. 4k is entering the picture and how long until 6k/8k/1080k (or whatever) enters the picture? What about gaming on an 8 year old computer that tops out at 1280x720? 1024x768? 640x400? My monitor supports 4k native, but It'd choke on the bandwidth required and max out at ...


6

There are a VAST number of reasons to allow the user to control the settings for their game. MANY people have 2 (or more) monitors these days. The user should be able to determine which one to play the game on. There are thousands of different devices a user could be using, and no way to reliably tell what setting would be optimal for every one. Some users ...


20

There are already some good answers here but to add one more, there is no way to completely reliably detect the correct screen resolution. Approach A is to simply not change it, leaving it at whatever desktop resolution the user uses. This is annoying as I know a number of people (some of whom have visual impairments) who like to run their desktop at a lower ...


2

Not only the predefined resolutions settings make it possible to react with performance in some way, but creating a universal approach, which fits all kinds of resolutions, ratios and dpis is just way much harder to create. If you create only few different resolutions, then it is user worry to choose best looking for him (especially when his ...


4

That's because the cost and effect of texture quality, geometry detail and screen resolution are very hardware-dependent. The texture quality usually does not have much impact on the speed of the rendering pipeline, but only when they are read from GPU memory. When not all textures fit into the GPU memory, they need to be read from normal RAM or even worse ...


42

So the user can choose the quality vs performance of the game. Some people would rather have the graphics settings on higher quality and the resolution lower, and others the opposite. Some computers can handle max everything, some cant. Notice that devices with the same hardware (PlayStation, Xbox, iPhone etc...) don't offer graphics settings (usually) ...


0

If the tiles are stored in a linear way( sorted so that the top left tile is first and the bottom right is last, or some other reasonable order ), you can access the array / list by an index that describes tiles that only lay within the screen bounds. This will be a bit faster than doing a bounds check every tile. Tile[,] tiles = new Tile[x,y]; We can now ...


1

Those kind of clouds are indeed rendered with perlin noise function. They can easily be generated on fly when the game starts, or they can be included in the game textures. There are ton of great tutorials out there to render perlin noise clouds, this being one of them: Perlin Noise, or this: How to Use Perlin Noise in Your Games You can find more by ...


0

You are talking about tiles, therefore i'm assuming you are talking about a 2d game. You need to have the camera position in the world like so: int cameraX = 0; int cameraY = 0; You also need to have the camera size, which is usually the same as your viewport size: int cameraWidth = viewportWidth; int cameraHeight = viewPortHeight; Then you can find ...


1

Have you tried a newer version of LibGDX? Support for GL 1 was removed a while ago so it seems that you're using an old version. It might fix the problem. If that doesn't work, can you show the rest of your code? Edit: Oh, and maybe change GL10.GL_COLOR_BUFFER_BIT to GL20.GL_COLOR_BUFFER_BIT Edit2: Okay, I noticed a few other things you can try. First, I ...


3

There are some really good answers here, so just to supplement them. A major driving force behind software rendering is capability. This was touched on in one of the answers, but I'm going to make an opposing point: software rendering can actually be more capable than hardware rendering, not less. With hardware you're generally limited to the capabilities ...


0

I think this is a really good question. What I can imagine is: VRAM is more limited than general RAM memory. In case of GPU rendering - every texture is more of an issue. You can store in average about 4 to 8 times more data in RAM than VRAM. Of course this scenario assumes that there is no system that is responsible for freeing/pushing unused/required ...


1

Without seeing your code, it's hard to give on solid answer, but here's an idea that might help you: The tail always points away from the previous piece of the snake. If we see the last piece of the snake as the tail, then the one that comes before it gives the direction of the connecting end of the tail, and the opposite direction is then the direction of ...


2

As you clearly already know what GPU rendering is... let me answer what you seem to be asking. Traditionally, hardware rendering has carried a stigma of being very complex. This has in large part been due to the design of the application programming interfaces (APIs) which have not been well-geared to concealing complexity; that is, the learning curve has ...


4

Hardware or GPU rendering is, as you guessed using the graphical processing unit (aka Video Card) to render an image. The opposite is software rendering where the CPU is used. Software rendering is usually used as a fallback when there is no (suitable) GPU available. However since the GPU is orders of magnitude faster software renders are almost never ...


0

Just make sure your sprites aren't going outside the canvas if you don't want them to and I think it's fine. You'd just have to alter the boundaries for the bodies in relation to the canvas in that case.


1

I can't read all of the source code (dang firewalls), but a display list is something that you compile once, then execute many times. What you're doing is telling OpenGL to regenerate an optimized execution list containing such and such triangle data every frame. That isn't what display lists were* used for -- they originally were more for things like old ...


4

Video cards without hardware T&L are dinosaurs. Seriously, there haven't been any new cards without hardware T&L since about 2000. Forget about them, just use hardware vertex processing and assume it's supported - unless you specifically need to support 14-year-old cards for some reason.


0

You can procedurally generate a rounded rectangle. You should probably use ShapeRenderer for this, as its rect and arc methods provide exactly what you need (five filled rectangles -- or two that overdraw -- and four filled arcs produce a rounded rectangle). I would strongly encourage you to build your rectangle this way and only worry about more complicated ...


0

When rendering 3D graphics you are always using a 3D mesh in some form or other. (Ignore the deprecated immediate mode.) So if you have a library that offers you to render a cube or a teapot, the underlying implementation basically has (or generates) a 3D mesh to render the shape. The straightforward way of rendering any non trivial shape is build the shape ...


1

You have to do two things here: Create a repeating sprite Mask it with the shape For the repeating sprite you will need a texture that has POT (Power Of Two) sides, e.g. 256x256. When you load your tiled texture you need to set its parameters to repeat: CCSprite* sprite = [CCSprite spriteWithFile:@"tiled_tex.png"]; ccTexParams params; params.minFilter ...


3

Most professional modelers have little expectation that the model in-game is going to look exactly like it does in Maya. The engineers have a very strong responsibility to provide tools for very quickly visualizing models using the game's rendering engine. This may be by allowing models to be re-loaded in game so there's no long shutdown/startup process to ...


1

3D modeling software packages like Maya usually include a great variety of options for rendering. For instance, Maya itself includes several software and hardware-accelerated renderers, and 3rd party renderer plugins can be used. Different renderers have different features and support different effects, but for the most part, they're designed for ...


2

This is going to depend on what you want to work with. Blender has an export feature which will allow you to export the models into several formats. If you want to write a customer parser, there are a few for various formats. You mentioned WebGL, which makes me think you're going to be working with JavaScript. With this in mind, Three.JS has some built in ...


1

The easiest approach is probably going to be exporting to COLLADA. Blender comes with a COLLADA exporter out of the box, so you'll just have to import the COLLADA XML data into your own data structures.


1

so surely the game engines needs the same render as Mayas to reproduce the effects created in Maya? They don't need to be the same, only the results need to be the same. Since you seem to think Maya's the reference, you can call what you see in Maya the expected result of a renderer rendering what is contained in the model. Break the renderer's stuff ...


2

OpenGL provides occlusion queries, described here. They are not exactly simple to use, but I believe they will do what you need. Basically, you create an occlusion query object, then "activate" it with glBeginQuery during the rendering that you want to analyze. After you are done drawing the geometry of interest, call glEndQuery and glGetQueryObject, ...


3

The .hdr format represents colors using a variant of floating-point format, so its maximum value is similar to that of float, i.e. about 10^38. In practice, you will likely not see values this large, but as you've found, different .hdr files may have very different value ranges. There is no standard for what the values in an .hdr image "mean". They could ...


3

The draw order often implied by tutorials, where you do something like this: for each object: for each pass: apply pass state draw object is actually backwards from how it makes sense to do it in a "real game" context. Rather, you'd be more likely to do something like: for each pass: apply pass state for each object (grouped ...


1

To keep rendering perfectly separate from the game logic, animations - at least the ones that have no game logic impact - are solely done from the "rendering" side. A common pattern is to record the transition using three bits of data: Start value End value Time (between 0 and 1) The advantage of this approach is that it can be easily fed into an easing ...


0

The code you are using to switch between 2D and 3D seems OK. Your problem should be on the GL states. Usually, when rendering sprites and 2D GUI, I use the following states: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); Then when switching back to 3D, I normally set: ...


4

While there is some interesting research into order-independent transparency rendering, it's extremely complex to implement. And even sorting individual leaves can still cause artifacts where one leaf overlaps itself. So your safest bet is probably Alpha Testing. This is where you specify a threshold opacity value; anything above that value is rendered 100% ...


1

Generally, quads can be replaced by triangles to save computational power. Since a quad is made of two triangles, you can simply make a bigger triangle that will encompass the whole particle texture (if any) and add it a transparency shader. You'll get an instant decrease of geometry computation by 50% compared to an all-quad system, for exactly the same ...



Top 50 recent answers are included