G'Day.... So if anyone has been following this project, you may have noticed a massive drop in progress, as in literally zero progress. I just wanted to make a quick post to say that this project is still very much on and at the forefront of my goals. I am currently moving house and have been spending all my "hobby" time on that. painting, ripping up carpet and laying wood floors, moving, arranging and so forth, digging up and rebuilding the path in the garden... etc etc. I just have no time to work on anything outside of my other time commitments. This is and will most likely always be a "hobby" and at this time I just have not had any time to work on it. That being said I should be finalising my move in the coming weeks. So I expect to get back into this project towards the end of February. So there is nothing to really report here, I just know a lot of hobby projects die out completely after a initial burst and wanted to say that this is not the case this time. See ya some when! --A4L

Hello everyone! I'm developing a game called "End of the Line", as a story-driven first-person horror stealth game. The main story revolves around a government agency, named the F.S.A., that captures and contains anomalous creatures or items that can't be explained by science. Think SCP but with quite a few differences. In the game's storyline, the agency is a worldwide conspiracy that was built to "protect" people from ever knowing about the true horrors of the world. Giant facilities pop up disguised as things like climate control centers or power facilities while secretly containing anomalies. The main struggle in the game comes from a group of civilians known as "The Defiance" with the sole goal of exposing the lies of the F.S.A. with a recruiter named "M" that interacts with players through messages and other hints. I wanted to stray away from quite a few horror tropes with this game so no devil worshipping, cults, crazy mental asylums, school children, or any of that stuff that's been seen time and time again. Just you and a killer creature slowly stalking you to drive you insane while you are trapped in a subway system. If there are any suggestions or criticism, I'd love to hear them! Thanks for all of your time!

Project Name: Condors Vs. Ocelots Team Size: 15ish Genre:Strategy RPG Engine: Unity Roles Available: Concept Artist, Environment Artist, Character Artist, C# Unity Dev Project Length: Currently planning on release Q1 2020. Compensation: Rev-share Project Description: Condors and Ocelots have been at war for generations. Battles have left some settlements in ruins. Others teem with refugees. Even away from the fighting, towns and villages suffer from having their fighting-age citizens lured away or conscripted by one faction or the other. Banditry is also rife -- since the Condors and Ocelots focus on the front lines, and largely neglect the parts of their respective dominions which aren't militarily important or located near their bases. The mysterious faction, Goatverlords, comes in and antagonizes both claiming rule of the land. They must work together and against one another to win the ultimate struggle. Project Status: 30-40% Done (Prepro done and dev started) Send emails to careers@titanomachystudios.com Our store page can be found here, https://play.google.com/store/apps/developer?id=Titanomachy+Studios Our website here, http://titanomachystudios.com/#/

Screenshot ! enjoy a few visual, work in progress. Everything you see is NOT completed and will improve, but we wish to share a little bit of what we have done so far. Screenshot description First image is from the current build with new UI. The compass minimap is only available on EASY. Remember, it is a hard game. Normal you keep the compass only. The compass is only available for Guigner, one of the three caracther, the navigator. It give you an overall idea of the direction of known area of interest. Not all of them will appear, but it's not fun when you have to seek very large open area and have no clue of what to do. It's not like linear game where the path is clear, in our game you can do what you want, the way you want and in the order you wish to do stuff. So to give you an idea of the zone that require your attention, you have the compass. Having this ability avaiable with only 1 character force you to switch and not always run with the same guy. You have to push button fast and use your brain. You have a close look of the crash site in the tutorial. Day 1 Screen 2 is a early preview of the crash site Screen 3 is a early preview of a path you could find and take if you feel adventurous screen 4 ... well, we can't do an alien game without cornfield. We will reveal why cropcircle exist screen 5 is a early preview of the famous hangar that act as a safe base for your character. You need to find it and gain access to it. The tutorial take place in a rural area in which you will learn all the game feature, control and mechanic but in a real game level. It's not a careless boring tutorial, it's an actual level that have more story driven content and yes, it is easier, but you can still die and get a gameover in there. You have ennemies to fight or avoid, it will increase you awereness level if you take wrong decision and it will have consequences for the rest of the game. We hope the tutorial to feel like a level. Old game had no tutorial, you just had to read the booklet, which we never did, or play and try yourself. Here, you get a little help. Game optimisation - CPU and GPU Lately, we decided to hold many content creatio to do some game optimisation as it was starting to feel it could go slow. It was a really important step to take. At first, my opinion was to don't bother and just push graphic, but it comes to a point that if you don't look at it, maybe you are doing stuff wrong and maybe you will be able to loose feature, change gameplay, adapt level, and redo a lot of stuff. Today my suggestion would be to start thinking about it not too soon, but as soon as you have enough script running at the same time. In unity, the editor profile is really helpful. At first it look quite confusing but when you look at the detail you can pinpoint which of your script is going bad in term of CPU usage, while GPU is all about managing geometry, light, shadow and passes. CPU hint any script that hit more than 0.2ms diserve to have a look at. Start by looking at the worst one and see what you can do. Update kill performance, we all know that. Instead of having a lot of them, try to find a way to trigger action by a bool switch, a collision, a key press, an action, etc. Some update are fine to have, like watching for a key. If you really really need update, think if a coroutine infinite loop would work (while(true)). You can add a delay between coroutine pass reducing the cpu work load. Almost no script need a "by frame" update. I have tried to implement a update manager, but it require a lot of work as you need to manage when and how to remove object and script update from the manager when you destroy or turn off item, so that idea was left behind. New version of unity seem to give the user better tool for that. Avoid "ontriggerstar", it will kill your cpu, just detect the in and out and have a coroutine calculate the time between them if you need to do stuff while you are inside the trigger. We did a lot of optimisation on animals agent and humanoid agent to limit their behavior on a closer distance to player and we clean up a lot of code to make the whole game much more efficient. Make sure also to manage your physics settings, there is no need to have your code react to every collision if you only want to detect your players collisions. Use layermask and physics wisely to reduce the cpu calculation and false call on your function. GPU hint this one I fell is less of a problem for PC game, but you still need to make sure your polycount is acceptable. If you use Vegetation Studio, this amount will rise up a lot because of the vegetation count itself. Stuff that have reflection like waterplane can have toggle that turn the object on and off depending on the player distance if culling doesn't work in wide and open space. Light is also a source of problem as it may increase the number of pass. Keep an eye on the culling settings of light and turn off everything that doesn't need to be lit by your light to reduce the passe. State of the game update The first level is still quite far from being complete, but every week important progress is made. At this point, we can actually play the game with one character. The level story is clear now, but content creation is not completed. Really important feature have been added and the UI as been rework to add information and fun to the game. Like in any good oldschool game, you need point, score, bonus, timer. We are adding detail and story element, once done, we will fine tune the level scenery, asset placement, overall look and everything. The game run at 45 fps inside the editor on an old machine. It has a gtx 1060 which does a fine job, but the bottle neck on the machine is the CPU (i7-2600k@4.7ghz). Running inside the editor is very heavy, optimisation is not over and there are a lof of DEBUG which consistanly write to the console, which is also very every. We have hope to reach 60fps near release on the test machine. All the core feature (script) is working and are optimised. We added many secondary feature and visuals for pickup, skills, etc. After many test, we had to leave the use of lightscattering. It was a deprecated feature we tried to include and improve but it brought many problem with graphic and performance and it was also producing game breaking error. Without any support from the author and the asset not being updated, we had to let it go. We will loose light scattering and good fog effect. On a good note, we gain stability and speed. It wasn't killing the atmosphere the remove the feature and we have other way to achieve what we wanted in the first place. It's the kind of feature we will revisit at the end. The in-game UI have been rework and is now mostly completed. Still need many graphic icon. Score, timer, bonus, scene stat, awerness stat, clock, compass and minimap added ! Added the ability to have scecret manually place bonus that will add up to your regular game bonus. The hangar scene still need audio 80% of the assets required to build 2 levels are completed. - We will soon add Tracsir and Zoile model and test special attack Temporal AA added. We are still updating/improving character controller and AI for better performance AI animals is completed and full system optimisation completed, animal attacking player need to be tested. Current Milestone : Build the tutorial level (so we can test all feature in 1 single map and improve them) (2 month remaining) - 30% done Next Milestone : Build a demo level to showcase the game (1-2 month) - 0% done Third Milestone : Finalise asset, playable character, sound and special FX of first 2 level (2 month) - 0% done

Hey! I feel spam, but I'm doing a project to draw all the gods of Nordic mythology to make an app that collects all the information about them and then add creatures and heroes. All the images and the interface will be created by me, unlike the other applications that take images of the internet. Any support I would appreciate PATREON: https://www.patreon.com/raijinsillustrations Odin the god of gods

Lets say we installed this https://github.com/JoshuaBrookover/bgfx.cmake using mkdir build cd build cmake .. cmake --build . --target install Because I didn't set build target/architecture + I'm using Windows, win32 debug installation will be at C:\Program Files (x86)\bgfx Okay, great. Now I can use find_package in module/config mode (well, not really. I need to write custom FindBGFX.cmake before that step, but we'll skip this part) and link bgfx with my another debug win32 project But what if I want to switch between Release and Debug? And what if I want support both x86 and x64? How to do that? Thank you in advance for your help! P.S. I know that debug libraries usually marked with "d" letter, but I still don't know how to deal with different architectures + how to install project for multiple architectures/build types using only 1 command line

I've been slowly progressing on my boating game over the past few weeks, it's been great that I seem to have a few people interested on youtube, despite me having no firm idea on a game design. I guess once you have water and land and boats you can use it for everything from racing to pirates / trading type games. Physics Physics has (allegedly) improved since my last blog post, instead of taking just one height sample at the centre of a boat I now use 3 samples in a triangle, to get an idea of the normal at the sea surface. This means that boats can now more closely match the surface instead of just up / down. The up / down motion is now working through the physics, rather than my previous approach of running the physics on a level ocean, then applying wave height to the displayed model only. There are disadvantages and advantages to this and it is subject to change. On the plus side it should eventually interact correctly with things like land masses, but currently the impulses to push the boats to sea level cause mad jitter on beaches! Boats also can take off now if you drive them over waves over a certain speed. Skybox First I tried using the world environment to create a skybox in godot, but had very mixed success. It was easy to create a procedural sky but because of the PBR shaders, the boat models etc ended up having a horrible blue colour cast. I tried various methods to get rid of the cast but failed miserably. In the end as I'm not really interested in PBR for this game I changed the world environment just to clear to a blue colour without a skybox, and I created a quick manual skybox in blender which I move around as the camera moves (needs a little tweaking). This looks good enough for my purposes and it means it doesn't get used in the PBR lighting so no colour cast (in fact I suspect it is defaulting to simpler shaders). Moving Origin As I was thinking of maybe having large worlds with a lot of sea to cover, I decided to have a 'moving origin' system to prevent floating point error in physics etc. It is quite easy to put in at an early stage, but more of a nightmare if you leave it till later, so I put it in early. The third person camera is focused on a particular boat at any time (e.g. player), and if that boat moves more than a certain distance from the origin, the whole world resyncs so that the boat is now centred on the origin, and the objects around are all teleported to their offsets from the player. This seems to work fine providing it is done at the correct time in the physics. Land Originally I was thinking of a simple game at sea only, but then realised it would be a lot more flexible to have land too. First I experimented with a simple plane for a beach, with a static collision box underneath it for the physics. I was planning on having a few different variations of beach geography, then stitching them together. The more I experimented the more I got dissatisfied with this approach, as it looked very inorganic, so I brainstormed for some other techniques. The difficulty was as well as looking right the approach had to work efficiently with the physics (and the moving origin). I wondered about using Delauney triangulation with some random points to get some land masses, but having a nice c++ implementation already in my library, I couldn't quite face translating this to gdscript. Plus, how would I handle the physics? Maybe Godot handles some polygon soup, but it would probably not be pretty. Next stop was a heightmap, but again I was worried about the efficiency of the physics and lots of special cases. Then this morning in bed I had a brainwave. Yesterday I had been experimenting and Godot has the ability to automatically build a convex hull physics rep around a mesh. I know from previous experience convex hulls work pretty good with physics, so instead of making e.g. a beach with this technique, why not create an entire island? Maybe I could just place islands on top of each other, interpenetrating, to create more complex coastline? It probably will look awful on the joins but given the ease of implementation this is my current winning technique. I made a quick low poly island in blender this morning, used the 'convex hull' operator in blender to ensure it was convex, UV mapped it and then did a quick texture paint in 3d paint. Whapped it in the game, added a convex hull static collider, and it's working great! Usually in these situations I'd also do procedural texturing but gdscript is a little slow for that, when I tried it in my frogger game, so probably just some manual textures for a few island types will do the trick. Anyway the final result is shown in the video. There might be some physics jiggle on the beach in this, I have to work on the boat physics on land, there seems to be some crazy interpenetration physics bug even in simple circumstances with a box against convex hull, maybe it is a bullet bug or some scaling or epsilon that is wrong.

Hi, I have to implement depth-shadow-mapping whith DirectX 12. It would be no problem for me to implement it in DX11, but in DX12 many things are quite new and puzzeling. Under normal conditions, I wouldn't waist your precious time, but there exist no literature or websites which makes the things clearer for me. I only found the book of Frank Luna: "Introduction to 3D Game Programming with DirectX 12", which is very good, but doesn't go deeper into DX12. Especially I have no idea, how to pass the information of the depth buffer of the first shadowmapping renderpass to the shadowmap-texture of the second main renderpass. I thought, I have to create a depth buffer resource with a dsv and take the same resource to make a srv for the second main renderpass. But it doesn't seem to work, for the scene doesn't cast any shadow. Here I added the pieces of my code, which are relevant for my problem, to make the things easier to read, the variable name includes the complete type mame in small cases: I would really appreciate help from an directx12 expert. Many thanks in advance! // Initialisation method of the depth dhadowmapping-renderpass, uxShadowMap and uyShadowMap are the resolution of the shadowmap: void CDirectX12Basic::InitShadowRenderpass(unsigned int uxShadowMap, unsigned int uyShadowMap) { HRESULT hresult; m_viewportShadow.MinDepth = 0.0f; m_viewportShadow.MaxDepth = 1.0f; m_viewportShadow.Width = (FLOAT)uxShadowMap; m_viewportShadow.Height = (FLOAT)uyShadowMap; m_rectScissorShadow.bottom = 0; m_rectScissorShadow.left = 0; m_rectScissorShadow.right = uxShadowMap; m_rectScissorShadow.bottom = uyShadowMap; // --------------------------------------------------- // Creating Depth/Stencil Buffers for the Shadow-Pass: // -------------------------------------------------- D3D12_DEPTH_STENCIL_DESC depthstencildesc; depthstencildesc.DepthEnable = true; depthstencildesc.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL; depthstencildesc.DepthFunc = D3D12_COMPARISON_FUNC_LESS; depthstencildesc.StencilEnable = false; depthstencildesc.StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK; depthstencildesc.StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK; depthstencildesc.FrontFace.StencilFailOp = D3D12_STENCIL_OP_KEEP; depthstencildesc.FrontFace.StencilDepthFailOp = D3D12_STENCIL_OP_KEEP; depthstencildesc.FrontFace.StencilPassOp = D3D12_STENCIL_OP_KEEP; depthstencildesc.FrontFace.StencilFunc = D3D12_COMPARISON_FUNC_ALWAYS; depthstencildesc.BackFace.StencilFailOp = D3D12_STENCIL_OP_KEEP; depthstencildesc.BackFace.StencilDepthFailOp = D3D12_STENCIL_OP_KEEP; depthstencildesc.BackFace.StencilPassOp = D3D12_STENCIL_OP_KEEP; depthstencildesc.BackFace.StencilFunc = D3D12_COMPARISON_FUNC_ALWAYS; D3D12_DEPTH_STENCIL_VIEW_DESC depthstencilviewdesc = {}; depthstencilviewdesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; // From the example in the book of Frank-Luna, is the stencil-buffer really necessary? depthstencilviewdesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D; depthstencilviewdesc.Flags = D3D12_DSV_FLAG_READ_ONLY_DEPTH; depthstencilviewdesc.Texture2D.MipSlice = 0; m_clearvalueShadow.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; // From the example in the book of Frank-Luna m_clearvalueShadow.DepthStencil.Depth = 1.0f; m_clearvalueShadow.DepthStencil.Stencil = 0; D3D12_RESOURCE_DESC resourcedescDepthStencil = {}; resourcedescDepthStencil.Format = DXGI_FORMAT_R24G8_TYPELESS; // laut Luna-Buch resourcedescDepthStencil.Width = (UINT64)uxShadowMap; resourcedescDepthStencil.Height = uyShadowMap; resourcedescDepthStencil.DepthOrArraySize = 1; resourcedescDepthStencil.MipLevels = 0; resourcedescDepthStencil.SampleDesc.Count = 1; resourcedescDepthStencil.SampleDesc.Quality = 0; resourcedescDepthStencil.Flags = D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; resourcedescDepthStencil.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; resourcedescDepthStencil.Alignment = 0; resourcedescDepthStencil.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; D3D12_HEAP_PROPERTIES heappropertiesDepthStencil = {}; heappropertiesDepthStencil.Type = D3D12_HEAP_TYPE_DEFAULT; heappropertiesDepthStencil.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN; heappropertiesDepthStencil.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN; heappropertiesDepthStencil.CreationNodeMask = 1; heappropertiesDepthStencil.VisibleNodeMask = 1; D3D12_DESCRIPTOR_HEAP_DESC descriptorheapdescDepthStencil = {}; descriptorheapdescDepthStencil.NumDescriptors = 1; descriptorheapdescDepthStencil.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV; descriptorheapdescDepthStencil.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE; hresult = m_pdevice->CreateDescriptorHeap(&descriptorheapdescDepthStencil, IID_PPV_ARGS(&m_pdescriptorheapDepthStencilShadow)); CHECK_N_DRECK(hresult, "CreateDescriptorHeap for Shadow-Depth-Stencil"); D3D12_DESCRIPTOR_HEAP_DESC descriptorheapdescDepthStencil2Pass = {}; descriptorheapdescDepthStencil2Pass.NumDescriptors = 1; descriptorheapdescDepthStencil2Pass.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV; descriptorheapdescDepthStencil2Pass.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; hresult = m_pdevice->CreateDescriptorHeap(&descriptorheapdescDepthStencil2Pass, IID_PPV_ARGS(&m_pdescriptorheapDepthStencilShadow2Pass)); CHECK_N_DRECK(hresult, "CreateDescriptorHeap second Pass for Shadow-Depth-Stencil"); hresult = m_pdevice->CreateCommittedResource( &heappropertiesDepthStencil, D3D12_HEAP_FLAG_NONE, &resourcedescDepthStencil, D3D12_RESOURCE_STATE_GENERIC_READ, &m_clearvalueShadow, IID_PPV_ARGS(&m_pressourceDepthStencilShadow) ); CHECK_N_DRECK(hresult, "CreateCommittedResource for Shadow-Depth-Stencil-Buffer"); m_cpudescriptorhandleShadowDSV = m_pdescriptorheapDepthStencilShadow->GetCPUDescriptorHandleForHeapStart(); m_pdevice->CreateDepthStencilView(m_pressourceDepthStencilShadow, &depthstencilviewdesc, m_cpudescriptorhandleShadowDSV); D3D12_INPUT_ELEMENT_DESC ainputelementdesc[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }, { "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 16, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }, { "TANGENT", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 32, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }, { "BITANGENT", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 48, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }, { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 64, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 } }; D3D12_INPUT_LAYOUT_DESC inputlayoutdesc; inputlayoutdesc.pInputElementDescs = ainputelementdesc; inputlayoutdesc.NumElements = 5; // Pos + Normal + Tangent + Bitangent + Texcood = 5 Params !!! (getestet!) #ifdef _DEBUG UINT uCompilerflags = D3DCOMPILE_DEBUG | D3DCOMPILE_OPTIMIZATION_LEVEL3; #else UINT uCompilerflags = D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_LATEST | D3DCOMPILE_PARTIAL_PRECISION | D3DCOMPILE_SKIP_VALIDATION | D3DCOMPILE_OPTIMIZATION_LEVEL3; #endif ID3DBlob * pblobVertexShader; hresult = D3DCompileFromFile(L"shaders\\Source\\DirectX12_ShadowVertexshader.hlsl", 0, 0, "main", "vs_5_1", uCompilerflags, 0, &pblobVertexShader, 0); CHECK_N_DRECK(hresult, "D3DCompileFromFile (ShadowMap Vertex Shader)"); ID3DBlob * pblobPixelShader; hresult = D3DCompileFromFile(L"shaders\\Source\\DirectX12_ShadowPixelshader.hlsl", 0, 0, "main", "ps_5_1", uCompilerflags, 0, &pblobPixelShader, 0); CHECK_N_DRECK(hresult, "D3DCompileFromFile (ShadowMap Pixel Shader)"); // --------------------------------------------- // Creating Constant Buffers of the Shadow-Pass: // --------------------------------------------- ZeroMemory(&m_arootparameterShadow, sizeof(D3D12_ROOT_PARAMETER) * NR_OF_ROOT_PARAMETERS); unsigned int uRootParameter = 0; unsigned int uRegisterConstant = 4; m_uRootParameterWorldViewProjShadow = uRootParameter; m_uRegisterWorldViewProjShadow = uRegisterConstant; m_bufferconstantWorldViewProjShadow.InitPSO(m_pdevice, sizeof(SBufferCpuWorldViewProjShadow), m_arootparameterShadow, D3D12_SHADER_VISIBILITY_VERTEX, uRootParameter++, uRegisterConstant++); //--------------------------------------------- // creating Root Signature for the Shadow-Pass: //--------------------------------------------- D3D12_ROOT_SIGNATURE_DESC rootsignaturedesc; ZeroMemory(&rootsignaturedesc, sizeof(rootsignaturedesc)); rootsignaturedesc.NumParameters = uRootParameter; // Aazahl der Ruudparameda rootsignaturedesc.pParameters = &m_arootparameterShadow[0]; rootsignaturedesc.Flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT | D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS | D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS | D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS; D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS; ID3DBlob * pblobRootSignature = NULL; ID3DBlob * pblobRootSignatureError = NULL; hresult = D3D12SerializeRootSignature(&rootsignaturedesc, D3D_ROOT_SIGNATURE_VERSION_1, &pblobRootSignature, &pblobRootSignatureError); CHECK_N_DRECK(hresult, "D3D12SerializeRootSignature for Shadow Map"); hresult = m_pdevice->CreateRootSignature(0, pblobRootSignature->GetBufferPointer(), pblobRootSignature->GetBufferSize(), IID_PPV_ARGS(&m_prootsignatureShadow)); CHECK_N_DRECK(hresult, "CreateRootSignature for Shadow Map"); //-------------------------------------------- // Creating PipelineStateDesc for Shadow-Pass: //-------------------------------------------- D3D12_GRAPHICS_PIPELINE_STATE_DESC pipelinestatedesc = { 0 }; pipelinestatedesc.VS.pShaderBytecode = pblobVertexShader->GetBufferPointer(); pipelinestatedesc.VS.BytecodeLength = pblobVertexShader->GetBufferSize(); pipelinestatedesc.PS.pShaderBytecode = pblobPixelShader->GetBufferPointer(); pipelinestatedesc.PS.BytecodeLength = pblobPixelShader->GetBufferSize(); pipelinestatedesc.pRootSignature = m_prootsignatureShadow; pipelinestatedesc.BlendState.AlphaToCoverageEnable = FALSE; pipelinestatedesc.BlendState.IndependentBlendEnable = FALSE; for (int i = 0; i < 8; i++) { pipelinestatedesc.BlendState.RenderTarget[i].BlendEnable = TRUE; pipelinestatedesc.BlendState.RenderTarget[i].LogicOpEnable = FALSE; pipelinestatedesc.BlendState.RenderTarget[i].SrcBlend = D3D12_BLEND_SRC_ALPHA; pipelinestatedesc.BlendState.RenderTarget[i].DestBlend = D3D12_BLEND_INV_SRC_ALPHA; pipelinestatedesc.BlendState.RenderTarget[i].BlendOp = D3D12_BLEND_OP_ADD; pipelinestatedesc.BlendState.RenderTarget[i].SrcBlendAlpha = D3D12_BLEND_ONE; pipelinestatedesc.BlendState.RenderTarget[i].DestBlendAlpha = D3D12_BLEND_ZERO; pipelinestatedesc.BlendState.RenderTarget[i].BlendOpAlpha = D3D12_BLEND_OP_ADD; pipelinestatedesc.BlendState.RenderTarget[i].LogicOp = D3D12_LOGIC_OP_NOOP; pipelinestatedesc.BlendState.RenderTarget[i].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL; } pipelinestatedesc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID; pipelinestatedesc.RasterizerState.CullMode = D3D12_CULL_MODE_BACK; pipelinestatedesc.RasterizerState.FrontCounterClockwise = TRUE; pipelinestatedesc.RasterizerState.DepthClipEnable = TRUE; pipelinestatedesc.RasterizerState.DepthBias = 0; // In the Frank Luna-example 10000, but make this realy sense? pipelinestatedesc.RasterizerState.DepthBiasClamp = 0.0f; // example of Frank Luna pipelinestatedesc.RasterizerState.SlopeScaledDepthBias = 1.0f; // example of Frank Luna pipelinestatedesc.RasterizerState.MultisampleEnable = FALSE; pipelinestatedesc.RasterizerState.AntialiasedLineEnable = FALSE; pipelinestatedesc.RasterizerState.ForcedSampleCount = 0; pipelinestatedesc.RasterizerState.ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF; pipelinestatedesc.SampleMask = UINT_MAX; pipelinestatedesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE; // A Shadow Pass has no RenderTargets!: pipelinestatedesc.NumRenderTargets = 0; pipelinestatedesc.RTVFormats[0] = DXGI_FORMAT_UNKNOWN; / pipelinestatedesc.DSVFormat = resourcedescDepthStencil.Format; pipelinestatedesc.SampleDesc.Count = 1; pipelinestatedesc.DepthStencilState = depthstencildesc; // Hier gehen die Infos für den Input Assembler rein: pipelinestatedesc.InputLayout = inputlayoutdesc; hresult = m_pdevice->CreateGraphicsPipelineState(&pipelinestatedesc, IID_PPV_ARGS(&m_ppipelinestateShadow)); CHECK_N_DRECK(hresult, "CreateGraphicsPipelineState for ShadowMap"); // ----------------------------------------- // Configuriering of Schadow-Render Targets: // ----------------------------------------- // Die Größe eines Descriptiors variiert von Grafikkarte zu Grafikkarte und Hersteller zu Hersteller (Intel, NVIDEA, AMD), // Daher muss sie abgefragt werden. RTV steht für Render Target View: for (int iFrame = 0; iFrame < FRAMES; iFrame++) { m_abufferrendertargetShadow[iFrame].InitShadow(m_pdevice, m_pressourceDepthStencilShadow, m_commandqueuedesc.Type, m_cpudescriptorhandleShadowDSV, m_ppipelinestateShadow); } // ------------------------------------------------------------ // Creating the Shadow-Map-View for the second main Renderpass: // ------------------------------------------------------------ D3D12_SHADER_RESOURCE_VIEW_DESC shaderresourceviewdesc = {}; ZeroMemory(&shaderresourceviewdesc, sizeof(shaderresourceviewdesc)); shaderresourceviewdesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; shaderresourceviewdesc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; shaderresourceviewdesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; shaderresourceviewdesc.Texture2D.MipLevels = 1; shaderresourceviewdesc.Texture2D.MostDetailedMip = 0; shaderresourceviewdesc.Texture2D.ResourceMinLODClamp = 0.0f; shaderresourceviewdesc.Texture2D.PlaneSlice = 0; m_cpudescriptorhandleShadowSRV = m_pdescriptorheapDepthStencilShadow2Pass->GetCPUDescriptorHandleForHeapStart(); m_pdevice->CreateShaderResourceView(m_pressourceDepthStencilShadow, &shaderresourceviewdesc, m_cpudescriptorhandleShadowSRV); m_aheapShadowMap[0] = m_pdescriptorheapDepthStencilShadow2Pass; m_gpudescriptorhandleShadow = m_pdescriptorheapDepthStencilShadow2Pass->GetGPUDescriptorHandleForHeapStart(); } ... // Main render method, the parameters are for the model-view-projection of the second renderpass: void CDirectX12Basic::RenderViewport(CHMat & mProjection, CHMat & mView, CHVector & vCamPos, CViewport &viewport) { WaitForPreviousFrame(); UINT uFrame = m_pswapchain->GetCurrentBackBufferIndex(); // ------------------------ // First shadow-renderpass: // ------------------------ m_abufferrendertargetShadow[uFrame].Open(m_apcommandlistShadow[uFrame]); m_apcommandlistShadow[uFrame]->RSSetViewports(1, &m_viewportShadow); m_apcommandlistShadow[uFrame]->RSSetScissorRects(1, &m_rectScissorShadow); m_apcommandlistShadow[uFrame]->SetGraphicsRootSignature(m_prootsignatureShadow); m_apcommandlistShadow[uFrame]->SetPipelineState(m_ppipelinestateShadow); // ... // Here: Drawing the relvant geometry for shadow casting // ... m_abufferrendertargetShadow[uFrame].Close(m_apcommandlistShadow[uFrame]); ID3D12CommandList * pcommandlistsShadow[] = { m_abufferrendertargetShadow[uFrame].m_pcommandlist }; m_pcommandqueue->ExecuteCommandLists(1, pcommandlistsShadow); // Param1: Anzahl der CommandLists // ----------------------- // Second main renderpass: // ----------------------- m_abufferrendertarget[uFrame].Open(m_apcommandlist[uFrame]); m_apcommandlist[uFrame]->RSSetViewports(1, &m_viewport); m_apcommandlist[uFrame]->RSSetScissorRects(1, &m_rectScissor); m_apcommandlist[uFrame]->SetGraphicsRootSignature(m_prootsignature); m_apcommandlist[uFrame]->SetPipelineState(m_ppipelinestate); m_buffersampler.Draw(m_apcommandlist[uFrame]); // ------------------------------------------------------------------------------------------------------- // The Binding of the depth-Buffer of the first Renderpass to the shadowe-msap-texture of the second pass: // I suppose, that I'm doing here sdomething wrong: // ------------------------------------------------------------------------------------------------------- m_apcommandlist[uFrame]->SetDescriptorHeaps(1, m_aheapShadowMap); m_apcommandlist[uFrame]->SetGraphicsRootDescriptorTable(m_uRootParameterShadowMap, m_gpudescriptorhandleShadow); m_lights.FillBufferCpuLight(m_abuffercpulight); m_buffersrtructuredLights.Tick(m_apcommandlist[uFrame], m_abuffercpulight); CHMat mProj; mProj = mProjection; mProj.Transpose(); CHMat mViewProj = mProj* mView; // I'm doing a precompiling of the View-Projection to speed up, it's not done in the vertex shader, is this a good idea? // The Method DrawGeos passes the relvant geometry to the main vertex shader, it works fine: DrawGeos(m_apcommandlist[uFrame], mViewProj, vCamPos); m_abufferrendertarget[uFrame].Close(m_apcommandlist[uFrame]); ID3D12CommandList * pcommandlists[] = { m_abufferrendertarget[uFrame].m_pcommandlist }; m_pcommandqueue->ExecuteCommandLists(1, pcommandlists); }

A quick word on sound effects. I found a fantastic online tool which allows you to create retro sounding effects. You can randomly create a sound then there are lots of tools to tweak the sounds to make it exactly how you want. I created some sounds and saved them as WAV files. I found they were too quiet so I loaded them into Audacity and used the Amplify feature to make them all the same volume. The link to ChipTone is here http://sfbgames.com/chiptone/

Hi Im designing several open-world games. Generally you are free to roam and do different things. You collect items or gain abilities or resources and can push further into the world or attempt harder tasks. How to avoid that the game feels grindy or repetative? I rely on procedurally generated worlds mostly. As an example: I work on a reimagening of "lost dutchman mine". You play a miner in the wild west. You search for deposits, mine valuables, sell them in towns and buy equipment and supplies to keep finding better mines or travel to harder areas with more dangers (and payoff). But it already feels slightly grindy... Is this a consequence of wanting stuff to be "realistic"? Like you need to gain money to buy food and things to keep going, at the same time the money is also what you need to progress etc. If you have a linear set of "levels" such as in super mario it would be easier I think: each designed challenge needs to be completed and then the game gives you another challenge. But in an sort of open world, how can I handle this better?

Why Bullet Time is your best choice to survive? Have you ever felt alone in the middle of the battle, desperate to survive against a massive horde of zombies? Us too. And that’s why we are so glad to introduce you the Bullet Time skill, an abbility really useful once you need more time to kill your enemies. Just imagine for one second how funny could be to freeze the time for a while and see these horrible enemies rushing over you in slow motion. That gives you a break to choose the best response. Lots of situation could happen then. You could kill more zombies, or find a way out, give orders to your troops in order to take a huge advantage on the battle. Also, it looks pretty cool to kill zombies in slow motion. Bullet Time improvements Fixed duration (we’re thinking about the possibility to last more depending on the player's level experience ). Bullet Time cooldown reduced. Time skills (Doesn't use stamina). Improved SFX feedback. New camera effect for feedback Much Better aiming while using the shotgun. Take advantage of the Bullet Time and the new shotgun. It looks amazing while killing a lot of zombies. Just try it! We will talk about other kind of weapons in our Discord Server. Join us!

Hey guys, We have new screenshots of our game in development showing you the art style. And even if there is still a lot of work to do, things missing here and there, and unfinished textures, we can say that we are quite happy with it. I hope you will enjoy them. More screenshots on our Steam page Thank you for reading!

Hi! I have a legacy question about HLSL SM 3.0 half versus float. I know that in the ps_5_0 profile, half is just a 'typedef' of float and the GPUs generally aren't required to support half-precision ALU. However when I run this simple shader: float x; float4 main() : COLOR0 { half y = x * 0.125; // <- "TYPECAST" HERE return float4(y, y, y, y); } through fxc.exe /T ps_3_0, it generates a "mul_pp" DXBC instruction, whereas with floats only, it generates "mul". What is the driver going to do with it? I reckon it won't honour this and just use single-precision floats everywhere. Do desktop SM 3.0 GPUs even support half-precision ALU? Thanks!

I have written an algorithm which resolves collisions between axis aligned rectangles so that they are resting against one another after collision resolution. The code is in Java using LibGDX public class Rectangle { public Vector2 position; public float halfW, halfH; private Vector2 restingDistance, currentDistance, overlap; public Rectangle(Vector2 position, float halfW, float halfH) { this.position = position; this.halfW = halfW; this.halfH = halfH; this.restingDistance = new Vector2(); this.currentDistance = new Vector2(); this.overlap = new Vector2(); } public boolean intersects(Rectangle rectangle) { return (position.x - halfW < rectangle.position.x + rectangle.halfW && position.x + halfW > rectangle.position.x - rectangle.halfW && position.y - halfH < rectangle.position.y + rectangle.halfH && position.y + halfH > rectangle.position.y - rectangle.halfH); } public void resolveCollision(Rectangle rectangle) { // Calculate the resting distance of the two rectangles restingDistance.set(halfW + rectangle.halfW, halfH + rectangle.halfH); // Calculate the current distance between the two rectangles currentDistance.set(position.x - rectangle.position.x, position.y - rectangle.position.y); // Calculate the overlap between the two rectangles overlap.set(restingDistance.x - Math.abs(currentDistance.x), restingDistance.y - Math.abs(currentDistance.y)); // Remove the overlap of the axis with the greater overlap overlap.set(overlap.x < overlap.y ? overlap.x : 0, overlap.y < overlap.x ? overlap.y : 0); // Reverse the direction of the overlap depending on the positions of the rectangles overlap.set(position.x < rectangle.position.x ? -overlap.x : overlap.x, position.y < rectangle.position.y ? -overlap.y : overlap.y); // Add the overlap to the rectangles position position.add(overlap); } } The code is used like this if(rectangle1.intersects(rectangle2)) { rectangle1.resolveCollision(rectangle2); } From my testing the code works. Colliding rectangles are moved out of collision so that they are resting against one another. Are there any problems with the way the code resolves collisions? Can the collision resolution code be improved and if so how? Thank you.

Our first game - Marble Knight - is beta now. We are looking for testers and hope that you help us out. We thank you for your feedback, which you can easily give us via the Google feedback bar in the Play Store. Download here: https://play.google.com/store/apps/details?id=com.DevilCookieGames.MarbleKnight

I am trying to use DXT5 compressed format. I load this with GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, but I can't find any option for sRGB. (for instance, non-compressed textures use GL_SRGB8_ALPHA8)

Hello, Games like Assassin's creed and various others position enemies around the player in a meaningful way, I have been wondering how this problem is generally solved. The way i solved it in a previous project was to use UE4 EQS with a Backend system to register attackers into a List. They each would request an attack each tick until the system returned a "token" stating they are now able to attack, this was to reduce the number of attackers to say 2 at a time each with there own offset. The attacker would enter an attack radius defined by there min and max attack distance and perform there attack then back off to an appropriate approach radius signifying they were no longer an active attacker. However im wondering how other programmers have approached this and weather there are any suggestions to improve this system such as maybe using attack weighting to define which enemy gets an attack as opposed to just handing them out in a first come first serve basis. Also the expensive path finding each time the player moves all the AI's have to re-evaluate the EQS points and create a new path to them. Note: UE4 and EQS are not specific to the question just a background of my exerpeince as this type of system could be implemented in a custom engine or unity etc. Thanks!

Ray Tracing Gems, a book with the goal of educating developers at all levels about important concepts and the state of the art in ray tracing, is due to be released mid-March in hardback form, but the contents are being made available at no cost as the chapters reached a finished state in the weeks leading up to the hardbook release. Today NVIDIA Developer Zone posted Part II of the book here. Keep an eye on the book's page as the schedule shows new parts released every few days until February 25, 2019. View full story

Ray Tracing Gems, a book with the goal of educating developers at all levels about important concepts and the state of the art in ray tracing, is due to be released mid-March in hardback form, but the contents are being made available at no cost as the chapters reached a finished state in the weeks leading up to the hardbook release. Today NVIDIA Developer Zone posted Part II of the book here. Keep an eye on the book's page as the schedule shows new parts released every few days until February 25, 2019.

Hey - me and my team are working on a 1 v 1 FPS game in Unity, and are actually quite far along (you can find some updates on our twitter: https://twitter.com/DibbieGames), having the majority of programming and audio covered - and now, we are looking for artists to help us reach the finish line. We are currently looking for a 2D artist who can create “stylized”/cartoony HUD/UI/UX elements such as health bars, crosshairs, weapon icons, menu buttons, sliders, etc, and possibly backgrounds for our menu screens. We are also looking for a 3D artist or two, who can create weapon models, and animate our rigged characters – all details about exactly who we are looking for, their exact requirements, responsibilities, and overview of the project can be found here: https://drive.google.com/open?id=1E1vBu3zB7mOb3yYfjdoV7OJHz_gEhnQA7kwj8j9dls0 If you are interested in joining the project, or if you have any questions, feel free to contact me on Discord: Dibbie#0408 or email: dibbieknight@gmail.com This is a voluntary project that does not intend to make any money. Our current goal is to release on Steam for PC in about 4 to 6 months. You can find updates on our Twitter, I try to post there as often as I can. Please provide at least 2 examples of your work (WIP's are fine), and/or a website/portfolio (DeviantArt, ArtStation, etc are fine). If you do not have any of the above, be willing to take an "art test" to demonstrate your art style and creativity.