• Advertisement

JTippetts

Moderator
  • Content count

    3576
  • Joined

  • Last visited

Community Reputation

13040 Excellent

4 Followers

About JTippetts

  • Rank
    Moderator

Personal Information

  • Interests
    Art
    Design
    Programming

Social

  • Github
    JTippetts

Recent Profile Visitors

57490 profile views
  1. The basic building block of competency is strong familiarity with the language. You only get that with practice and experience, just like with any other skill. With skill and competency comes the ability to solve ever more complex problems. (And an RPG of any significant scale and scope is a quite complex problem.) A child doesn't start out running marathons; she starts out crawling first, then walking a few steps. Similarly, you won't be building that Dark Souls or Witcher 3-like RPG anytime soon, not until you've learned to run. Tutorials can only get you so far, are very frequently of poor quality, and are a very poor substitute for basic competency. A tutorial is tantamount to that child using a chair to hold herself up in a standing position. In order to build the RPG you envision, you MUST get past the "I need a tutorial to teach me this" stage. You have to be able to reason about and design and construct solutions on your own, and there just aren't any tutorials for that.
  2. Nothing in your list of stuff is impossible to do as a single developer. Similar things have been done before by solo devs. However, relying upon finding tutorials to help you accomplish all of the tasks probably isn't feasible. Your immediate goal should be to learn enough about design, development, patterns and techniques that you can reason your way to solutions on your own, rather than rely on tutorials to hold your hand the whole way through it. The best way to learn those patterns and techniques is to build smaller games. Even if they are not games that you ever release, they will still teach you a lot of the things you need to know to build larger projects.
  3. U3DTerrainEditor

    U3DTerrainEditor is a simple terrain editor written using the Urho3D engine. Current features include splatted terrain using up to 8 terrain texture types, choice of tri-planar or standard texture mapping, optional tiling reduction and choice of smooth or textured blending between texture types. 3 mask layers that can be used to mask off various operations. Brush-based editing of height, terrain blending and masks. Node-based UI for constructing noise functions that can be output to any of the terrain layers, terrain height, or masks. Features Lua-scripted filters that can be applied to the whole terrain, or to masked areas, including Erosion, Cavity fill, Cliffify, as well as a spline-based Road tool and a spline-based River tool. This project is still very much in develop, and many features are still quite rudimentary. See the README.md file at the Github project page for current building and operating instructions. Pre-built binary for Windows is available at the Download link.
  4. U3DTerrainEditor Project Page

    Yeah, not sure it really brings anything new to the table, to be honest. I just kinda like working on it, usually when I get burned out working on my game.
  5. U3DTerrainEditor Project Page

    I've created a project page for the U3DTerrainEditor I have been working on. Project now includes a downloadable Windows binary so you can try it out. Warning: rough code ahead. It's still a pretty unpolished project, but you can do some cool stuff with it regardless. Your first terrain: 1) Download the archive, unpack, and execute either run_opengl.bat or run_d3d11.bat. Alternatively, you can execute TEdit.exe or TEdit_D3D11.exe directly, passing arguments on the commandline; ie, TEdit.exe LuaScripts/terraineditor.lua -w to run windowed instead of borderless. The batch scripts execute in borderless windowed mode. 2) Click on the NodeGraph button in the toolbar, represented by 3 boxes linked by lines. A window will popup in the lower right. Click new to create a new Node Group, then click Edit to edit the new node group. An overlay window will popup with a + button to create nodes, and an output widget. 3) Click on +, navigate to library, then click on ridged. A node for a Ridged fractal should appear. Change the value of the Frequency input to 3. Click and drag on the output link of the node, and drag the link to the input of the output widget. When the link is established, click the Preview button. The preview pane should fill with a preview image of the node function. 4) At the bottom of the output widget, ensure that Terrain is selected as the Output Target, then click Execute. After a brief processing pause, you should see the terrain change in the background. Press 'm' to close the node window. 5) Click on the Filters button. (It looks like a magic wand). From the list of filters, select Erosion. In the Power box, enter an erosion power (or just stay with 0.3, which is a decent choice). Power values can range from 0 to 0.5. Click Execute. After a brief prcoessing delay, the terrain should change again showing the results of the erosion applied. 6) From filters, select the Cliffify filter. In the dropdown box for Layer, select Layer 7. Press execute. After processing, the terrain should change so that steep areas show a cliff-like texture. 7) Select the Cavity Map to Layer filter. In the Layer dropdown box, select Layer 2, then press execute. The terrain should change again, showing sandy texture in the bottom of hollows and depressions. 8) Press the Terrain Options button (represented as a gear wheel). Select the Save button next to the Terrain: label, enter a filename, and hit Save to save the terrain heightmap to a PNG file. Heightmap will be saved as a standard RGB PNG, with height stored in the Red and Green channels. Red is the coarse height, and Green is finer detail data, allowing the heightmap to represent more than just 256 levels of elevation and making a smoother heightmap. Height can be extracted as Red + Green/255.0f. Of course, there is a lot more you can do with it. There are brushes for manually editing terrain, texture layers and masks. You can use masks to protect areas from being edited or modified. You can create a spline (use 'q' and 'e' to remove and create knots) then use the Road filter or River filter to create areas of road and river. You can export the texture blend layers as well as a normal map. Some stuff still might not be hooked up right, and as always this is a work in progress. If you have any feedback or suggestions, let me know.
  6. C++ SDL_Rect Scope

    It should be the same for all the calls. Anything they need, they'll hold internally.
  7. C++ SDL_Rect Scope

    What you are doing is fine. SDL_RenderDrawRect copies out what it needs from the passed rectangle, and sends that data along to SDL_RenderDrawLines.
  8. I am looking for this tutorial (2D art)

    You might check out the polycount wiki for hand-painting stylistic textures. Googling for hand-painted and stylistic texture tutorials might net you a few additional forum threads and/or articles. Try polycount, zbrushcentral, blenderartists, etc... Edit: Might check this mini-tute thread by an artist working on one of the World of Warcraft expansions. Has a whole bunch of neat images to look at, plus some tutorial discussion later. WoW artists are always fantastic resources for learning about stylistic textures.
  9. Multiperception Game Engine

    I've read through the thread twice, and I still have no idea what you are trying to do. Granted, I'm kinda slow, but I'd still wager I'm not the only one.
  10. Does u,v,w texture mapping exist?

    This sounds like an XY Problem. In this case, your problem sounds like "how do I make good looking fire?" Cube mapping probably isn't the best solution. You might try looking at particle systems instead. Barring that, there is always raymarching a volume texture inside the shader to create a fire effect.
  11. Rip internet 2017-12-14

    Because there was no internet before the net neutrality rules, right?
  12. Mostly just a lot of googling. I 'got started' by playing various roguelikes back in the day, then at some point I purchased the book Texturing and Modeling: A Procedural Approach and that got me started on using noise functions. After that, it was all just various experimentation and some internet googling.
  13. Never underestimate the power of erosion. Also, spend some time looking at actual terrain on Google maps satellite view. One thing you will see is that terrain varies across different scales. In your sample shot, you have two types of terrain: flat and bumpy. All the bumps are the same scale, across the entire terrain, indicating that you are probably just using a simple fractal of some sort. Fractals can be useful as a building block tool, but not really as an end in themselves. Look at throwing other building blocks into your arsenal, such as Worley's cellular functions, domain turbulence, etc... (Here is an example using a cellular F2-F1 function with fractal domain turbulence: clicky). You can also look into using fractals that incorporate the previous layer's derivative, to give a sort of eroded look without an explicit erosion pass. Íñigo Quílez talks about this some, and it is in fact the technique used by the Shadertoy shader in @piluve's post. This article by Giliam de Carpentier presents a couple different variants of derivative noise. As far as the detail goes, if you are going to use a lower resolution terrain as you are, you can use a normal map that covers the entire terrain to 'fake' the smaller details. Those details wouldn't have any effect on gameplay (ie, they wouldn't affect the geometry that the player walks on) they just affect the visual result, adding shading detail to make it look like the terrain is higher resolution than it really is.
  14. Are you asking only about procedural content used IN the game, or do you include procedural generation as a part of the game creation process? Because even games that have static (ie, not generated at run-time) worlds frequently make use of procedural stuff during the creation phases. For example, using algorithms to generate a large chunk of terrain, then using editing tools to make modifications such as building placement, spawn locations, etc.... The procedurals allow the designer to quickly rough-in large areas, rather than forcing them to hand-create every mountain and ridge and valley. Algorithms also allow for more advanced realism, ie an erosion pass on a generated terrain, then using splines to locate roads and rivers and trails. Stuff like that (realistic terrain) is quite difficult to hand-model, but quite easy to model using algorithms as a starting point. I've got a terrain editor in the works that allows to do just that kind of thing. Rapidly generate a terrain from various functions, erode and perform various editing and texturing tasks, place some roads or rivers using splines, then export height and texture blend maps. You can very quickly (ie, in just a few minutes) rough-out a large map. (An example.) As far generation techniques go, I've experimented a bit with some of it and have written about various things over the years in my blog, including generating rock and dirt textures using particle system scattering in Blender, generating a side-scroller level using 3D blocks, generating Minecraft-like block worlds, generating mountain tiles for a 2D game, creating textures from noise functions (more), procedural islands, and so on, and so on. Some of the stuff I've played with have been in-game techniques, but most of it has been for offline content creation stuff. Other techniques I've used include noise functions (quite extensive), tile-based stuff, Wang tiles, architectural grammars, space colonization for procedural trees, meta-tiles (where the 'tile' is a large piece, such as an entire dungeon room, complete with contents), drunkard's walk, labyrinth generation, and many more. Personally, I see procedural generation as a critical part of the game design process, even if only during content creation. With a comprehensive set of rules, you can generate levels for simple puzzle games all the way up to entire open worlds populated with fleshed-out NPCs and monsters.
  15. The Poor Man's 3D Camera

    This was an interesting read. I love to read about other people solving their problems. It always sorta nudges my own thinking around about my own stuff.
  • Advertisement