Jump to content
  • Advertisement


Senior Moderator
  • Content Count

  • Joined

  • Last visited

  • Days Won


Everything posted by Promit

  1. Promit

    PhysX 4.0 Announced as Open Source

    NVIDIA has announced a christmas present with the release of PhysX SDK 4.0 later this month, open sourced under the 3-clause BSD license. The big technical change in the physics engine appears to be the temporal Gauss-Seidel solver, enabling faster and more robust handling of contact points and constraints. For full details, please see https://news.developer.nvidia.com/announcing-physx-sdk-4-0-an-open-source-physics-engine/
  2. I apologize for not having the time to really review the discussion in this thread, although I'm very pleased with how the community seems to have handled it. Very little black and white, which is good. For my part, I set out building our own tech eight years ago for a variety of reasons, and now I run a funded company with shipping products built on top of that engine. And for as many things as that engine lacks, it has a few key things which allow us to do things that we would have had significant trouble pulling off in UE and are not actually possible in Unity. We're redoubling our effort to bring that engine up to 2020 standards, in our own way and with a mix of custom and off-the-shelf components. I have seven figures of investment (past and future) banking on this project, it's not a toy by any means although it is quite domain specific.
  3. A few days ago I was setting up a new resource build pipeline for our games, and wanted to integrate the build directly in Visual Studio. The goal was to include a resource manifest file in the project, and have them be fed to my compiler as part of the normal VC project build. Often the starting point for this is a simple command line entered as a Custom Build Event, but those are basically just dumb commands that don’t follow the project files at all. The next step up from there is configuring a Custom Build Tool on the files in question. This works well once you have it set up, but there are distinct drawbacks. Each file is configured completely separately, and there’s no way to share configuration. Adding the file to the project doesn’t do anything unless you go in and set several properties for the build tool. There has to be a better way. Setting all of these fields up gets old real quick.After asking around for that better way, I was pointed to Nathan Reed’s excellent write-up on Custom Targets and toolchains in VS. By setting up this functionality, you can configure a project to automatically recognize certain file extensions, and execute a predefined build task command line on all of them with correct incremental builds. This build customization system works great, and is absolutely worth setting up if that’s all you need! I followed those instructions and had my resource manifests all compiling nicely into the project – until I wanted to add an extra command line flag to just one file. It turns out that while the build customization targets are capable of a lot, the approach Nathan takes only takes you so far and effectively forces you to run the same command line for all of your custom build files. The file is now recognized as a “Resource Pack” and will build appropriately! But we have no options about how to build it and no ability to tweak the command line sent.With some help from Nathan and a lot of futzing around with modifications of the custom build targets included with VS, I’ve managed to do one better and integrate my resource builds fully into VS, with property pages and configurable command line. What follows is mostly just a stripped down copy of the masm (Microsoft Macro Assembler) build target, but should offer a good basis to work from. Now we have property pages for our custom target, along with custom properties for the command line switches.Command line display, including a box to insert additional options.For this type of custom build target, there are three files you will need: .props, .xml, and .targets. We’ll look at them in that order. Generally all three files should have the same name but the appropriate extension. Each one has a slightly different purpose and expands on the previous file’s contents. I’m not going to dwell too much on the particulars of MSBuild’s elements and format, but focus on providing listings and overviews of what’s going on. The props file provides the basic properties that define our custom build task. <?xml version="1.0" encoding="utf-8"?> <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <ItemDefinitionGroup> <ResourcePackTask> <!--Enter Defaults Here--> <ComputeHashes>false</ComputeHashes> <SuppressJson>false</SuppressJson> <BuildLog>false</BuildLog> <ManifestFileName>$(OutDir)Resources\%(Filename).pack</ManifestFileName> <AdditionalOptions></AdditionalOptions> <CommandLineTemplate>$(KataTools)KataBuild.exe [AllOptions] [AdditionalOptions] --manifest %(FullPath) $(OutDir)Resources</CommandLineTemplate> </ResourcePackTask> </ItemDefinitionGroup> </Project> My task is called “ResourcePackTask” and you’ll see that name recurring throughout the code. What I’m doing here is to define the properties that make up my ResourcePackTask, and give them default values. The properties can be anything you like; in my case they’re just names representing the command line switches I want to provide as options. These are not necessarily GUI-visible options, as that will be configured later. Just think of it as a structure with a bunch of string values inside it, that we can reference later as needed. The key component in this file is the CommandLineTemplate, which makes up its own syntax for options that doesn’t seem to appear anywhere else. [AllOptions] will inject the switches configured in the GUI, and [AdditionalOptions] will add the text from the Command Line window. It’s otherwise normal MSBuild syntax and macros. Next up is the .xml file. This file’s main role is to configure the Visual Studio GUI appropriately to reflect your customization. Note that VS is a little touchy about when it reads this file, and you may need to restart the IDE for changes to be reflected. We’ll start with this basic version that doesn’t add any property sheets: <?xml version="1.0" encoding="utf-8"?> <ProjectSchemaDefinitions xmlns="http://schemas.microsoft.com/build/2009/properties" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:sys="clr-namespace:System;assembly=mscorlib"> <ItemType Name="ResourcePackTask" DisplayName="Resource Pack" /> <ContentType Name="ResourcePackTask" DisplayName="Resource Pack" ItemType="ResourcePackTask" /> <FileExtension Name=".pack" ContentType="ResourcePackTask" /> </ProjectSchemaDefinitions> So far we’ve told the IDE that any time it sees a file with the extension “.pack”, it should automatically categorize that under “ResourcePackTask”. (I’m unsure of the difference between ContentType and ItemType and also don’t care.) This will put the necessary settings into place to run our builds, but it would also be nice to have some property sheets. They’re called “Rules” in the XML file for some reason, and the syntax is straightforward once you have a reference: <?xml version="1.0" encoding="utf-8"?> <!-- This file tells the VS IDE what a resource pack file is and how to categorize it --> <ProjectSchemaDefinitions xmlns="http://schemas.microsoft.com/build/2009/properties" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:sys="clr-namespace:System;assembly=mscorlib"> <Rule Name="ResourcePackTask" PageTemplate="tool" DisplayName="Resource Pack" SwitchPrefix="" Order="300"> <Rule.Categories> <Category Name="General" DisplayName="General" /> <Category Name="Command Line" Subtype="CommandLine"> <Category.DisplayName> <sys:String>Command Line</sys:String> </Category.DisplayName> </Category> </Rule.Categories> <Rule.DataSource> <DataSource Persistence="ProjectFile" ItemType="ResourcePackTask" Label="" HasConfigurationCondition="true" /> </Rule.DataSource> <StringProperty Name="Inputs" Category="Command Line" IsRequired="true"> <StringProperty.DataSource> <DataSource Persistence="ProjectFile" ItemType="ResourcePackTask" SourceType="Item" /> </StringProperty.DataSource> </StringProperty> <StringProperty Name="CommandLineTemplate" DisplayName="Command Line" Visible="False" IncludeInCommandLine="False" /> <StringProperty Subtype="AdditionalOptions" Name="AdditionalOptions" Category="Command Line"> <StringProperty.DisplayName> <sys:String>Additional Options</sys:String> </StringProperty.DisplayName> <StringProperty.Description> <sys:String>Additional Options</sys:String> </StringProperty.Description> </StringProperty> <BoolProperty Name="ComputeHashes" DisplayName="Compute resource hashes" Description="Specifies if the build should compute MurMur3 hashes of every resource file. (--compute-hashes)" Category="General" Switch="--compute-hashes"> </BoolProperty> <BoolProperty Name="SuppressJson" DisplayName="Suppress JSON output" Description="Specifies if JSON diagnostic manifest output should be suppressed/disabled. (--no-json)" Category="General" Switch="--no-json"> </BoolProperty> <BoolProperty Name="BuildLog" DisplayName="Generate build log" Description="Specifies if a build log file should be generated. (--build-log)" Category="General" Switch="--build-log"> </BoolProperty> </Rule> <ItemType Name="ResourcePackTask" DisplayName="Resource Pack" /> <ContentType Name="ResourcePackTask" DisplayName="Resource Pack" ItemType="ResourcePackTask" /> <FileExtension Name=".pack" ContentType="ResourcePackTask" /> </ProjectSchemaDefinitions> Again I don’t ask too many questions here about this thing, as it seems to like looking a certain way and I get tired of constantly reloading the IDE to see if it likes a particular variation of the format. The file configures the categories that should show in the properties pane, indicates that the properties should be saved in the project file, and then lists the actual properties to display. I’m using StringProperty and BoolProperty, but two others of interest are StringListProperty (which works like the C++ include directories property) and EnumProperty (which works like any number of multi-option settings). Here’s a sample of the latter, pulled from the MASM.xml customization: <EnumProperty Name="ErrorReporting" Category="Advanced" HelpUrl="https://msdn.microsoft.com/library/default.asp?url=/library/en-us/vcmasm/html/vclrfml.asp" DisplayName="Error Reporting" Description="Reports internal assembler errors to Microsoft. (/errorReport:[method])"> <EnumValue Name="0" DisplayName="Prompt to send report immediately (/errorReport:prompt)" Switch="/errorReport:prompt" /> <EnumValue Name="1" DisplayName="Prompt to send report at the next logon (/errorReport:queue)" Switch="/errorReport:queue" /> <EnumValue Name="2" DisplayName="Automatically send report (/errorReport:send)" Switch="/errorReport:send" /> <EnumValue Name="3" DisplayName="Do not send report (/errorReport:none)" Switch="/errorReport:none" /> </EnumProperty> All of these include a handy Switch parameter, which will eventually get pasted into our command line. At this point the IDE now knows what files we want to categorize, how to categorize them, and what UI to attach to them. The last and most complex piece of the puzzle is to tell it what to do with the files, and that’s where the .targets file comes in. I’m going to post this file in a few pieces and go over what each piece does. <?xml version="1.0" encoding="utf-8"?> <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <ItemGroup> <PropertyPageSchema Include="$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml" /> <AvailableItemName Include="ResourcePackTask"> <Targets>_ResourcePackTask</Targets> </AvailableItemName> </ItemGroup> First, we declare that we want to attach property pages to this target, point the IDE to the xml file from before, and tell it what the name of the items is that we want property pages for. We also give it a Target name (_ResourcePackTask) for those items, which will be referenced again later. <UsingTask TaskName="ResourcePackTask" TaskFactory="XamlTaskFactory" AssemblyName="Microsoft.Build.Tasks.v4.0, Version=, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"> <Task>$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml</Task> </UsingTask> This is the weird part. In Nathan’s write-up, he uses a CustomBuild element to run the outside tool, but CustomBuild doesn’t have a way of getting the command line switches we set up. Instead we’re going to ask the MSBuild engine to read the provided assembly and ask its XamlTaskFactory to generate our ResourcePackTask. That XamlTaskFactory compiles a new C# Task object on the fly by reflecting our definitions from the .xml file (and maybe the .props file). This seems like an insane way to design a build system to me, but what do I know? In any case that seems to be how all of the MS tasks are implemented out of the box, and we’ll follow their lead verbatim. Let’s move on. <Target Name="_WriteResourcePackTaskTlogs" Condition="'@(ResourcePackTask)' != '' and '@(SelectedFiles)' == ''"> <ItemGroup> <_ResourcePackTaskReadTlog Include="^%(ResourcePackTask.FullPath);%(ResourcePackTask.AdditionalDependencies)" Condition="'%(ResourcePackTask.ExcludedFromBuild)' != 'true' and '%(ResourcePackTask.ManifestFileName)' != ''"/> <!-- This is the important line to configure correctly for tlogs --> <_ResourcePackTaskWriteTlog Include="^%(ResourcePackTask.FullPath);$([MSBuild]::NormalizePath('$(OutDir)Resources', '%(ResourcePackTask.ManifestFileName)'))" Condition="'%(ResourcePackTask.ExcludedFromBuild)' != 'true' and '%(ResourcePackTask.ManifestFileName)' != ''"/> </ItemGroup> <WriteLinesToFile Condition="'@(_ResourcePackTaskReadTlog)' != ''" File="$(TLogLocation)ResourcePackTask.read.1u.tlog" Lines="@(_ResourcePackTaskReadTlog->MetaData('Identity')->ToUpperInvariant());" Overwrite="true" Encoding="Unicode"/> <WriteLinesToFile Condition="'@(_ResourcePackTaskWriteTlog)' != ''" File="$(TLogLocation)ResourcePackTask.write.1u.tlog" Lines="@(_ResourcePackTaskWriteTlog->MetaData('Identity')->ToUpperInvariant());" Overwrite="true" Encoding="Unicode"/> <ItemGroup> <_ResourcePackTaskReadTlog Remove="@(_ResourcePackTaskReadTlog)" /> <_ResourcePackTaskWriteTlog Remove="@(_ResourcePackTaskWriteTlog)" /> </ItemGroup> </Target> MSBuild operates by executing targets based on a dependency tree. This next section configures a Target that will construct a pair of .tlog files which record the dependencies and outputs, and enable the VS incremental build tracker to function. Most of this seems to be boring boilerplate. The key piece is where [MSBuild]::NormalizePath appears. This little function call assembles the provided directory path and filename into a final path that will be recorded as the corresponding build output file for the input. I have a hard coded Resources path in here for now, which you’ll need to replace with something meaningful. The build system will look for this exact filename when deciding whether or not a given input needs to be recompiled, and you can inspect what you’re getting in the resulting tlog file. If incremental builds aren’t working correctly, check that file and check what MSBuild is looking for in the Diagnostic level logs. I should note at this point that the tlog target is optional, and that as written it only understands the direct source file and its direct output. In my case, it will see changes to the resource manifest file, and it will see if the output is missing. But it has no information about other files read by that compile process, so if I update a resource referenced by my manifest it won’t trigger a recompile. Depending on what you’re doing, it may be better to omit the tlog functionality and do your own incremental processing. Another possibility is writing a process that generates the proper tlog. <Target Name="_ResourcePackTask" BeforeTargets="ClCompile" Condition="'@(ResourcePackTask)' != ''" Outputs="%(ResourcePackTask.ManifestFileName)" Inputs="%(ResourcePackTask.Identity)" DependsOnTargets="_WriteResourcePackTaskTlogs;_SelectedFiles" > <ItemGroup Condition="'@(SelectedFiles)' != ''"> <ResourcePackTask Remove="@(ResourcePackTask)" Condition="'%(Identity)' != '@(SelectedFiles)'" /> </ItemGroup> <Message Importance="High" Text="Building resource pack %(ResourcePackTask.Filename)%(ResourcePackTask.Extension)" /> <ResourcePackTask Condition="'@(ResourcePackTask)' != '' and '%(ResourcePackTask.ExcludedFromBuild)' != 'true'" CommandLineTemplate="%(ResourcePackTask.CommandLineTemplate)" ComputeHashes="%(ResourcePackTask.ComputeHashes)" SuppressJson="%(ResourcePackTask.SuppressJson)" BuildLog="%(ResourcePackTask.BuildLog)" AdditionalOptions="%(ResourcePackTask.AdditionalOptions)" Inputs="%(ResourcePackTask.Identity)" /> </Target> </Project> This is the last piece of the file, defining one more Target. This is the target that actually does the heavy lifting, and you’ll see the recurrence of the _ResourcePackTask name from earlier. There are two properties BeforeTargets and AfterTargets (not used here) that set when in the build process this target should run. It also takes a dependency on the tlog target above, so that’s how that target is pulled in. Again there is some boilerplate here, but we start the actual build by simply outputting a message that reports what file we’re compiling. Lastly, the ResourcePackTask entry here constructs the execution of the task itself. I think that %(ResourcePackTask.Whatever) here has the effect of copying the definitions from the .props file into the task itself; the interaction between these three files doesn’t seem especially well documented. In any case what seems to work is simply repeating all of your properties from the .props into the ResourcePackTask and they magically appear in the build. Here’s a complete code listing for the file. <?xml version="1.0" encoding="utf-8"?> <!-- This file provides a VS build step for Kata resource pack files --> <!-- See http://reedbeta.com/blog/custom-toolchain-with-msbuild/ for an overview of what's happening here --> <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <ItemGroup> <PropertyPageSchema Include="$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml" /> <AvailableItemName Include="ResourcePackTask"> <Targets>_ResourcePackTask</Targets> </AvailableItemName> </ItemGroup> <UsingTask TaskName="ResourcePackTask" TaskFactory="XamlTaskFactory" AssemblyName="Microsoft.Build.Tasks.v4.0, Version=, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"> <Task>$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml</Task> </UsingTask> <Target Name="_WriteResourcePackTaskTlogs" Condition="'@(ResourcePackTask)' != '' and '@(SelectedFiles)' == ''"> <ItemGroup> <_ResourcePackTaskReadTlog Include="^%(ResourcePackTask.FullPath);%(ResourcePackTask.AdditionalDependencies)" Condition="'%(ResourcePackTask.ExcludedFromBuild)' != 'true' and '%(ResourcePackTask.ManifestFileName)' != ''"/> <!-- This is the important line to configure correctly for tlogs --> <_ResourcePackTaskWriteTlog Include="^%(ResourcePackTask.FullPath);$([MSBuild]::NormalizePath('$(OutDir)Resources', '%(ResourcePackTask.ManifestFileName)'))" Condition="'%(ResourcePackTask.ExcludedFromBuild)' != 'true' and '%(ResourcePackTask.ManifestFileName)' != ''"/> </ItemGroup> <WriteLinesToFile Condition="'@(_ResourcePackTaskReadTlog)' != ''" File="$(TLogLocation)ResourcePackTask.read.1u.tlog" Lines="@(_ResourcePackTaskReadTlog->MetaData('Identity')->ToUpperInvariant());" Overwrite="true" Encoding="Unicode"/> <WriteLinesToFile Condition="'@(_ResourcePackTaskWriteTlog)' != ''" File="$(TLogLocation)ResourcePackTask.write.1u.tlog" Lines="@(_ResourcePackTaskWriteTlog->MetaData('Identity')->ToUpperInvariant());" Overwrite="true" Encoding="Unicode"/> <ItemGroup> <_ResourcePackTaskReadTlog Remove="@(_ResourcePackTaskReadTlog)" /> <_ResourcePackTaskWriteTlog Remove="@(_ResourcePackTaskWriteTlog)" /> </ItemGroup> </Target> <Target Name="_ResourcePackTask" BeforeTargets="ClCompile" Condition="'@(ResourcePackTask)' != ''" Outputs="%(ResourcePackTask.ManifestFileName)" Inputs="%(ResourcePackTask.Identity)" DependsOnTargets="_WriteResourcePackTaskTlogs;_SelectedFiles" > <ItemGroup Condition="'@(SelectedFiles)' != ''"> <ResourcePackTask Remove="@(ResourcePackTask)" Condition="'%(Identity)' != '@(SelectedFiles)'" /> </ItemGroup> <Message Importance="High" Text="Building resource pack %(ResourcePackTask.Filename)%(ResourcePackTask.Extension)" /> <ResourcePackTask Condition="'@(ResourcePackTask)' != '' and '%(ResourcePackTask.ExcludedFromBuild)' != 'true'" CommandLineTemplate="%(ResourcePackTask.CommandLineTemplate)" ComputeHashes="%(ResourcePackTask.ComputeHashes)" SuppressJson="%(ResourcePackTask.SuppressJson)" BuildLog="%(ResourcePackTask.BuildLog)" AdditionalOptions="%(ResourcePackTask.AdditionalOptions)" Inputs="%(ResourcePackTask.Identity)" /> </Target> </Project> With all of that in place, hypothetically Visual Studio will treat your fancy new file type and its attendant compile chain exactly how you want. There are probably still many improvements to be made – in particular, this scheme as written seems to suppress stdout from the console at the default “Minimal” MSBuild verbosity, which is something I haven’t dug into. But this is a solid start for a fully integrated build process. View the full article
  4. V3 build pictured, but the V4 upgrades are all internal to the pad.If you’re unfamiliar with my DanceForce work or the previous versions, please read the introduction of my V3 build post for the rationale and advantages of this particular approach to a hard pad and what I’m going for. In short, the DF is a slimmer, lighter hardpad that can be more reliable and consistent than conventional designs due to its use of pressure sensitive sensors that are separated from the “click action” of the actual steps. I’m now building the DanceForce V4 prototype. V4 is simpler, easier to build, requires less parts, and is cheaper. Traditionally I build and design these pads, make a bunch of tweaks, and play on them for a good while. Then I begin working on the draft of the instructional write-up, and eventually publish the full how-to guide. If I followed that timeline again, this V4 guide would appear in *checks notes* summer 2020. Let’s not do that. I began work this past weekend, so I’m just going to post a stream of photos and exactly what I’m doing as I go. Excluding pad graphics and a few incidentals, this pad costs about $160 to put together. Current Status: Core pad is done but top hasn’t been installed and control board hasn’t been assembled. These are not changed from V3. Building the Base Basic layout sketch of the initial cut pad.Note: the dimensions in this photo are slightly wrong and I had to go back and fix it. Always triple check your measurements before cutting and gluing!The base layer is 1/2″ plywood cut to 34″ x 33″. The extra inch on top will be useful for wiring. I’ve marked off the steps in pencil, and then begun adding the spacer layer. I’m using 1/8″ hardboard this time around, for shallower steps than in the past. My hope is this will reduce ankle stress and overall impact while playing barefoot. The bottom panels are 10.25″ square, the top are 10.25″ x 5.25″. The upper panels are sized to leave space for Start/Select buttons. Next step is beginning to lay out the contacts. I’m using 3″ copper tape today, but 4″ is probably even better because it’s less work and barely costs any more. I’ve added the hardboard spacers around the Start and Select buttons. Note that these go on AFTER the copper tape, which runs underneath it. Here’s a detail shot of what you’ll end up with: Finally, all of the contacts get connected together with a plus to serve as the common contact for the step sensors. That concludes the base layer. Sensor Construction Start by building the top contact. Cut four 10.5″ squares of Lexan, and cover one side in copper tape. Add a little strip around to the top side to serve as our connection point for later. It’s important here to place the contact strip off center. You don’t want it touching the extension strip on the common contact. I also clip the corners to leave space between steps.Place an 11″ square of Velostat over the bottom of the contact. It does not need to cover it completely. Then the top contact goes over it. The top contact MUST be insulated by Velostat on every edge or the step will not work. That’s why we cut it a little small. I’ve moved to 6 mil Velostat in the V4 design due to the higher sensitivity of pure copper contacts. Finally, duct tape secures the sensor in place. I’ve done a couple experiments now and it appears that too much duct tape is a bad idea. This is a pressure sensor and excessive tape applies so much pressure that there isn’t enough range left to reliably detect steps. The clipped corners leave space for hardboard strips that will fill the space between diagonal steps.Four assembled sensors. It’s a good idea to test them with a multimeter at this point, while the duct tape still isn’t that strongly bonded. You’re looking for 70+ ohms at rest, and sub-10 with foot pressure.I also add some corner boundaries at this stage. These are hardboard strips of 1.75″ x 0.5″ and they are important to have good corner separation of the steps. The gap is important, wiring is going to run through there. Electrical Get ready to break out the soldering iron – but we have some prep work to do first. Take a look at the edges where your top contacts are – is copper peeking out past the Velostat? We don’t want this. It will short if we try to take the contact over this section. A little strip of electrical or duct tape will insulate the boundary. That’s better. Now I’m going to build a solder pad from two layers of copper tape. This solder pad I’ve laid down does not connect to the top contact of the step yet. This way if the step needs to come out, the soldered wire can stay where it is.Now to solder some wires. It’s important to leave lots of extra length when cutting the wire, I’ve been screwed multiple times by not having enough spare lead. Be judicious with the heat. The copper tape solders decently enough but it’s not going to tolerate the iron for an extended period.Finally, one more layer of copper tape will link the top contact to the solder pad and shield it all in one go. And now all four arrows wired up: I’ll finish up Start and Select later. For now, we really need to neaten up those wires. Find a hot glue gun, route the wires nicely up through the top of the pad, and glue them in place. And with that, the internal construction of the pad is complete. View the full article
  5. This is Part 1 of a series examining techniques used in game graphics and how those techniques fail to deliver a visually appealing end result. See Part 0 for a more thorough explanation of the idea behind it. High dynamic range. First experienced by most consumers in late 2005, with Valve’s Half Life 2: Lost Coast demo. Largely faked at the time due to technical limitations, but it laid the groundwork for something we take for granted in nearly every blockbuster title. The contemporaneous reviews were nothing short of gushing. We’ve been busy making a complete god awful mess of it ever since. Let’s review, very quickly. In the real world, the total contrast ratio between the brightest highlights and darkest shadows during a sunny day is on the order of 1,000,000:1. We would need 20 bits of just luminance to represent those illumination ranges, before even including color in the mix. A typical DSLR can record 12-14 bits (16,000:1 in ideal conditions). A typical screen can show 8 (curved to 600:1 or so). Your eyes… well, it’s complicated. Wikipedia claims 6.5 (100:1) static. Others disagree. Graphics programmers came up with HDR and tone mapping to solve the problem. Both film and digital cameras have this same issue, after all. They have to take enormous contrast ratios at the input, and generate sensible images at the output. So we use HDR to store the giant range for lighting computations, and tone maps to collapse the range to screen. The tone map acts as our virtual “film”, and our virtual camera is loaded with virtual film to make our virtual image. Oh, and we also throw in some eye-related effects that make no sense in cameras and don’t appear in film for good measure. Of course we do. And now, let’s marvel in the ways it goes spectacularly wrong. In order: Battlefield 1, Uncharted: Lost Legacy, Call of Duty: Infinite Warfare, and Horizon Zero Dawn. HZD is a particular offender in the “terrible tone map” category and it’s one I could point to all day long. And so we run head first into the problem that plagues games today and will drive this series throughout: at first glance, these are all very pretty 2017 games and there is nothing obviously wrong with the screenshots. But all of them feel videogamey and none of them would pass for a film or a photograph. Or even a reasonably good offline render. Or a painting. They are instantly recognizable as video games, because only video games try to pass off these trashy contrast curves as aesthetically pleasing. These images look like a kid was playing around in Photoshop and maxed the Contrast slider. Or maybe that kid was just dragging the Curves control around at random. The funny thing is, this actually has happened to movies before. Hahaha. Look at that Smaug. He looks terrible. Not terrifying. This could be an in-game screenshot any day. Is it easy to pick on Peter Jackson’s The Hobbit? Yes, it absolutely is. But I think it serves to highlight that while technical limitations are something we absolutely struggle with in games, there is a fundamental artistic component here that is actually not that easy to get right even for film industry professionals with nearly unlimited budgets. Allow me an aside here into the world of film production. In 2006, the founder of Oakley sunglasses decided the movie world was disingenuous in their claims of what digital cameras could and could not do, and set out to produce a new class of cinema camera with higher resolution, higher dynamic range, higher everything than the industry had and would exceed the technical capabilities of film in every regard. The RED One 4K was born, largely accomplishing its stated goals and being adopted almost immediately by one Peter Jackson. Meanwhile, a cine supply company founded in 1917 called Arri decided they don’t give a damn about resolution, and shipped the 2K Arri Alexa camera in 2010. How did it go? 2015 Oscars: Four of the five nominees in the cinematography category were photographed using the ARRI Alexa. Happy belated 100th birthday, Arri. So what gives? Well, in the days of film there was a lot of energy expended on developing the look of a particular film stock. It’s not just chemistry; color science and artistic qualities played heavily into designing film stocks, and good directors/cinematographers would (and still do) choose particular films to get the right feel for their productions. RED focused on exceeding the technical capabilities of film, leaving the actual color rendering largely in the hands of the studio. But Arri? Arri focused on achieving the distinctive feel and visual appeal of high quality films. They better understood that even in the big budget world of motion pictures, color rendering and luminance curves are extraordinarily difficult to nail. They perfected that piece of the puzzle and it paid off for them. Let’s bring it back to games. The reality is, the tone maps we use in games are janky, partly due to technical limitations. We’re limited to a 1D luminance response where real film produces both hue and saturation shifts. The RGB color space is a bad choice to be doing this in the first place. And because nobody in the game industry has an understanding of film chemistry, we’ve all largely settled on blindly using the same function that somebody somewhere came up with. It was Reinhard in years past, then it was Hable, now it’s ACES RRT. And it’s stop #1 on the train of Why does every game this year look exactly the goddamn same? The craziest part is we’re now at the point of real HDR televisions showing game renders with wider input ranges. Take this NVIDIA article which sees the real problem and walks right past it. The ACES tone map is destructive to chroma. Then they post a Nikon DSLR photo of a TV in HDR mode as a proxy for how much true HDR improves the viewing experience. Which is absolutely true – but then why does the LDR photo of your TV look so much better than the LDR tone map image? There’s another tone map in this chain which nobody thought to examine: Nikon’s. They have decades of expertise in doing this. Lo and behold, their curve makes a mockery of the ACES curve used in the reference render. Wanna know why that is? It’s because the ACES RRT was never designed to be an output curve in the first place. Its primary design goal is to massage differences between cameras and lenses used in set so they match better. You’re not supposed to send it to screen! It’s a preview/baseline curve which is supposed to receive a film LUT and color grading over top of it. “Oh, but real games do use a post process LUT color grade!” Yeah, and we screwed that up too. We don’t have the technical capability to run real film industry LUTs in the correct color spaces, we don’t have good tools to tune ours, they’re stuck doing double duty for both “filmic look” as well as color grading, the person doing it doesn’t have the training background, and it’s extraordinary what an actual trained human can do after the fact to fix these garbage colors. Is he cheating by doing per-shot color tuning that a dynamic scene can’t possibly accomplish? Yes, obviously. But are you really going to tell me that any of these scenes from any of these games look like they are well balanced in color, contrast, and overall feel? Of course while we’re all running left, Nintendo has always had a fascinating habit of running right. I can show any number of their games for this, but Zelda: Breath of the Wild probably exemplifies it best when it comes to HDR. No HDR. No tone map. The bloom and volumetrics are being done entirely in LDR space. (Or possibly in 10 bit. Not sure.) Because in Nintendo’s eyes, if you can’t control the final outputs of the tone mapped render in the first place, why bother? There’s none of that awful heavy handed contrast. No crushed blacks. No randomly saturated whites in the sunset, and saturation overall stays where it belongs across the luminance range. The game doesn’t do that dynamic exposure adjustment effect that nobody actually likes. Does stylized rendering help? Sure. But you know what? Somebody would paint this. It’s artistic. It’s aesthetically pleasing. It’s balanced in its transition from light to dark tones, and the over-brightness is used tastefully without annihilating half the sky in the process. Now I don’t think that everybody should walk away from HDR entirely. (Probably.) There’s too much other stuff we’ve committed to which requires it. But for god’s sake, we need to fix our tone maps. We need to find curves that are not so aggressively desaturating. We need curves that transition contrast better from crushed blacks to mid-tones to blown highlights. LUTs are garbage in, garbage out and they cannot be used to fix bad tone maps. We also need to switch to industry standard tools for authoring and using LUTs, so that artists have better control over what’s going on and can verify those LUTs outside of the rendering engine. In the meantime, the industry’s heavy hitters are just going to keep releasing this kind of over-contrasty garbage. Before I finish up, I do want to take a moment to highlight some games that I think actually handle HDR very well. First up is Resident Evil 7, which benefits from a heavily stylized look that over-emphasizes contrast by design. That’s far too much contrast for any normal image, but because we’re dealing with a horror game it’s effective in giving the whole thing an unsettling feel that fits the setting wonderfully. The player should be uncomfortable with how the light and shadows collide. This particular scene places the jarring transition right in your face, and it’s powerful. Next, at risk of seeming hypocritical I’m going to say Deus Ex: Mankind Divided (as well as its predecessor). The big caveat with DX is that some scenes work really well. The daytime outdoors scenes do not. The night time or indoor scenes that fully embrace the surrealistic feeling of the world, though, are just fantastic. Somehow the weird mix of harsh blacks and glowing highlights serves to reinforce the differences between the bright and dark spots that the game is playing with thematically throughout. It’s not a coincidence that Blade Runner 2049 has many similarities. Still too much contrast though. Lastly, I’m going to give props to Forza Horizon 3. Let’s be honest: cars are “easy mode” for HDR. They love it. But there is a specific reason this image works so well. It is low contrast. Nearly all of it lives in the mid-tones, with only a few places wandering into deep shadow (notably the trees) and almost nothing in the bright highlights. But the image is low contrast because cars themselves tend to use a lot of black accents and dark regions which are simply not visible when you crush the blacks as we’ve seen in other games. Thus the toe section of the curve is lifted much more than we normally see. Similarly, overblown highlights mean whiting out the car in the specular reflections, which are big and pretty much always image based lighting for cars. It does no good to lose all of that detail, but the entire scene benefits from the requisite decrease in contrast. The exposure level is also noticeably lower, which actually leaves room for better mid-tone saturation. (This is also a trick used by Canon cameras, whose images you see every single day.) The whole image ends up with a much softer and more pleasant look that doesn’t carry the inherent stress we find in the images I criticized at the top. If we’re looking for an exemplar for how to HDR correctly in a non-stylized context, this is the model to go by. Where does all this leave us? With a bunch of terrible looking games, mostly. There are a few technical changes we need to make right up front, from basic decreases in contrast to simple tweaks to the tone map to improved tools for LUT authoring. But as the Zelda and Forza screenshots demonstrate, and as the Hobbit screenshot warns us, this is not just a technical problem. Bad aesthetic choices are being made in the output stages of the engine that are then forced on the rest of the creative process. Engine devs are telling art directors that their choices in tone maps are one of three and two are legacy options. Is it bad art direction or bad graphics engineering? It’s both, and I suspect both departments are blaming the other for it. The tone map may be at the end of graphics pipeline, but in film production it’s the first choice you make. You can’t make a movie without loading film stock in the camera, and you only get to make that choice once (digital notwithstanding). Don’t treat your tone map as something to tweak around the edges when balancing the final output LUT. Don’t just take someone else’s conveniently packaged function. The tone map’s role exists at the beginning of the visual development process and it should be treated as part of the foundation for how the game will look and feel. Pay attention to the aesthetics and visual quality of the map upfront. In today’s games these qualities are an afterthought, and it shows. UPDATE: User “vinistois” on HackerNews shared a screenshot from GTA 5 and I looked up a few others. It’s very nicely done tone mapping. Good use of mid-tones and contrast throughout with great transitions into both extremes. You won’t quite mistake it for film, I don’t think, but it’s excellent for something that is barely even a current gen product. This is proof that we can do much better from an aesthetic perspective within current technical and stylistic constraints. Heck, this screenshot isn’t even from a PC – it’s the PS4 version. View the full article
  6. I’m about to start a series of blog posts called Games Look Bad. Before I start throwing stones from my glass house over here, I wanted to offer an explanation of what I’m doing and a defense of why I’m doing it. There’s no doubt that we’ve seen a sustained and significant period of improvement in real-time computer graphics over the past three decades. We’ve made significant advances in nearly every aspect of visual look and feel, drawing quite a bit from the film industry in the process. So why the heck do most games look so bad? Games are technically much more sophisticated than ever before, but I’m going to stake out a claim: aesthetically something has gone quite wrong, and the products don’t live up to the hype. Show me a next-gen, cutting edge game and I will show you an image that no competent film industry professional would ever deem acceptable. Why not? The answer lives at the crossroads of art and technology, a strange neglected intermediary which we in the industry tend to avoid talking about. Particularly in the last ten years, several new techniques have appeared that are foundational to practically every high end game on the market. These are well documented from a technical standpoint, and it’s generally assumed that graphics programmers who have stayed current are fluent in at least the basic goals and implementations of these techniques, if not the finer points of them. I won’t labor to build a complete list, but you likely know them: normal maps, HDR/tonemaps, physically based shading, volumetrics, DoF/bokeh, etc. What’s extremely difficult to find, though, is a discussion of how to make these techniques visually appealing. Oh sure, we’ll sort of handwave it from time to time, but graphics programmers as a set don’t like talking about visual appeal in the way that artists do. It’s much easier to build the tools and then let the artists make it pretty. Except the artists, even the tech artists, don’t always have the know-how or mathematical tools to solve that problem. Sometimes we end up borrowing our looks from someone else – how many of you have googled FilmLut.tga? How many of you are using Unreal’s tone map operator, tweaked or even verbatim? This series is going to take a sharply critical tone towards most AAA games being shipped today, because it’s my belief that there are fundamental problems with many of the techniques we’re using today that reach beyond strictly technical constraints. Graphics programmers and engines are implementing many techniques for new effects without taking the time or energy to properly refine the visual and aesthetic aspects of those effects. Marketing tells us we should be impressed by all the new features, yet when you take a step back from the fact that these are games and evaluate the images without that context, they look horrible. This is a problem that is fixable today, with current technology. I don’t know if my thesis here is particularly well developed, but it’s a good excuse for the meat of this series. I don’t want to talk about how to implement techniques. There are many people who have done an excellent job of that and you should have that background coming in. I’m going to talk about the visual choices we make in these techniques, how they make our games better, how they make our games worse, and whether we’re using them well. I’m going to encourage everyone to think critically about why and how we’re implementing the things that make modern games tick, and examine the tunnel vision that has afflicted that process maybe since the beginning. And in the process, I’m going to criticize people’s work which far exceeds my own in every respect, while largely failing to provide solutions to problems. I know that and I accept it. And that is where we shall start. View the full article
  7. Today, we’re going to talk about how to configure a MIDI controller to act as a debugging aid for a game – or any software development project. Why a MIDI controller? Photo credit: Wikimedia Commons / CC BY-SA 3.0Why would you want to do this? It’s very common to have a set of internal variables that we want to tweak on the fly, while the game is running, until things are just right. There’s animation, physics, AI, game play and difficulty, graphics, UI, and more. Typically people end up homebrewing a variety of tricks to edit these variables. You might ‘borrow’ a couple keyboard keys and throw an on screen text display in. You might have a developer console command and type in the values. If you really get fancy, you might even have a TCP debug channel that can control things from another UI, maybe even on another computer. These options all have their pros and cons. Why add MIDI as another option to the mix? It’s really easy and safe to disable for releases. We’re probably not using MIDI for any legitimate user purpose, after all. It doesn’t require any UI, on any screen. Supports platforms like mobile where keystroke debugging can be particularly problematic. It’s quick to get to edit a large range of parameters in tandem. Editing without explicit numerical values avoids the problem of sticking to “convenient” numbers. It’s easy to give this setup to a non-technical person and let them toy around. Tactile editing is just plain fun. How does a MIDI controller work? Over the MIDI protocol, naturally. MIDI was standardized in 1983 as a way for musical tools like keyboards, samplers, sequencers, and all sorts of computerized devices to communicate with each other. While in ye olden days the connection was made over a 7 pin DIN cable, many modern controllers have USB interfaces. These are class compliant devices, which means you can simply plug them into a computer and go, without any drivers or mandatory support software. MIDI itself is a slightly wonky protocol, based strictly around events. There’s a wide range of events, but for our purposes we only really need four: Note On, Note Off, Control Change, and Program Change. Note On/Off are easy – they’re your key down/up equivalents for a MIDI controller. Control Change (CC) represents a value change on an analog control, like a knob or slider. Program Change changes an entire bank or preset. Note what’s not in there: state. The whole thing is designed to be stateless, which means no state queries either. But many MIDI controllers do have state, in the physical position of their knobs or sliders. That leads us to the dreaded MIDI CC jump. In short, what happens when a value in our software is set to 0 (min) and the user twists a knob is at 127 (max)? The knob will transmit a CC with a value of 126 attached, causing the variable it’s attached to to skyrocket. This desynchronization between software and hardware state can be confusing, inconvenient, and downright problematic. Choosing a MIDI controller Photo Credit: Behringer/MUSIC GroupEnter the Behringer X-Touch Mini. For a trivial $60 street at time of writing, take a look at what it gives us: 8 rotary encoders with LED collars for value display Volume slider 24 push buttons (8 push-knob, 16 LED) with configurable behavior (momentary/toggle) Dual control layers, so multiply everything above by two Simple class-compliant USB connectivity Now back up and read that again. Rotary encoders. LED collars. Get it? Encoders aren’t knobs – they spin freely. The value isn’t based on the position of a potentiometer, but digitally stored and displayed using the LEDs around the outside of each encoder. Same goes for the button states. This is a controller that can not only send CC messages but receive them too, and update its own internal state accordingly. (The volume slider is not digital and will still cause CC jumps.) Setting up the X-Touch Mini Photo Credit: Promit Roy / CC BY-SA 3.0Behringer offers a program called X-Touch Editor which you’ll want to download. Despite the terrible English and oddball UI, It allows you to configure the X-Touch Mini’s behavior and save it persistently onto the controller’s internal memory. You can change the display style of the LEDs (I recommend fan) and change the buttons between momentary (like a keyboard button) and toggle (push on, push again off). It also offers other options for MIDI behavior, but I recommend leaving that stuff where it is. For my purposes, I set the center row of buttons to act as toggles, and left the rest of it alone. Understanding the MIDI protocol At this stage it might be helpful to download a program called MIDI-OX. This is a simple utility that lets you send and monitor MIDI messages, which is very useful in understanding exactly what’s happening when you are messing with the controller. Note that MIDI devices are acquired exclusively – X-Touch Edit, MIDI-OX, and your own code will all lock each other out. The MIDI messages we’ll be using have a simple structure: a four bit message ID, a four bit channel selection, followed by one or two data bytes. The X-Touch Mini is configured to use channel 11 for its controls out of the box. Here are the relevant message IDs: enum MidiMessageId { MIDI_NoteOn = 144, MIDI_NoteOff = 128, MIDI_ControlChange = 176, MIDI_ProgramChange = 192, }; Channels are 0 based in the protocol, so you’ll add 10 to these values when submitting them. NoteOn and NoteOff are accompanied by a note ID (like a key code) and a velocity (pressure). The key codes go from 0-23 for layer A, representing the buttons left to right and top to bottom. When you switch to layer B, they’ll switch over to 24-47. You’ll receive On and Off to reflect the button state, and you can also send On and Off back to the controller to set Toggle mode buttons on or off. This is really handy when hooked up to internal boolean variables: light on = true, light off = false. We’re not interested in the pressure field, but it does need to be set correctly. The values are 127 for NoteOn and 0 for NoteOff. ControlChange (CC) will appear any time the knobs are rotated, with the knob ID and the current value as data bytes. The default range is 0-127; I recommend leaving it that way and rescaling it appropriately in software. For layer A, the knob IDs go from 1-8 (yes, they’re one based) and the slider is assigned to 9. On layer B that’ll be 10-17 and 18. You can transmit identical messages back to the controller to set the value on its end, and the LED collar will automatically update to match. The X-Touch will never send you a ProgramChange (PC) by default. However on the current firmware, it will ignore messages that don’t apply to the currently active layer. You can send it a Program Change to toggle between layer A (0) and B (1), and then send the rest of your data for that layer to sync everything properly. PC only has a single data byte attached, which is the desired program. Writing the MIDI glue code Go ahead and grab RtMidi. It’s a nice little open source library, which is really just composed of a single header and source file pair, but supports Windows, Linux, and Mac OSX. (I have an experimental patch for iOS support as well that may go up soon.) I won’t cover how to use the library in detail here, as that’s best left to the samples – the code you need is right on their homepage – but I will give a quick overview. You’ll need to create two objects: RtMidiIn for receiving data, and RtMidiOut for sending it. Each of these has to be hooked to a “port” – since multiple MIDI devices can be attached, this allows you to select which one you want to communicate with. The easiest thing to do here is just to search the port lists for a string name match. At this point it’s just a question of signing up for the appropriate callbacks and parsing out their data, and then sending the correct messages back. The last step is to bidirectionally synchronize variables in your code to the MIDI controller. I did it with some template/macro nonsense: void GameStage::MidiSyncOut() { if(_midiOut) { _midiOut->Send(MIDI_ProgramChange, 0); MidiVars(1, 0, 0, 0); _midiOut->Send(MIDI_ProgramChange, 1); MidiVars(1, 0, 0, 0); _midiOut->Send(MIDI_ProgramChange, 0); } } void GameStage::NoteOn(unsigned int channel, unsigned int note, unsigned int velocity) { MidiVars(0, 0, note, velocity); } void GameStage::NoteOff(unsigned int channel, unsigned int note, unsigned int velocity) { MidiVars(0, 0, note, velocity); } void GameStage::ControlChange(unsigned int channel, unsigned int control, unsigned int value) { MidiVars(0, 1, control, value); } template<typename T1, typename T2, typename T3> void MidiVariableOut(const T1& var, T2 min, T3 max, unsigned int knob, MidiOut* midiOut) { float val = (var - min) / (max - min); val = clamp(val, 0.0f, 1.0f); unsigned char outval = unsigned char(val * 127); midiOut->Send(MIDI_ControlChange + 10, knob, outval); } template<typename T1, typename T2, typename T3> void MidiVariableIn(T1& var, T2 min, T3 max, unsigned int knob, unsigned int controlId, unsigned int noteOrCC, unsigned char value) { if(noteOrCC && knob == controlId) { float ratio = value / 127.0f; var = T1(min + (max - min) * ratio); } } void MidiBoolOut(const bool& var, unsigned int button, MidiOut* midiOut) { if(var) midiOut->Send(MIDI_NoteOn + 10, button, 127); else midiOut->Send(MIDI_NoteOff + 10, button, 0); } void MidiBoolIn(bool& var, unsigned int button, unsigned int controlId, unsigned int noteOrCC, unsigned char value) { if(!noteOrCC && button == controlId) { var = value > 0; } } #define MIDIVAR(var, min, max, knob) inout ? MidiVariableOut(var, min, max, knob, _midiOut) : MidiVariableIn(var, min, max, knob, controlId, noteOrCC, value) #define MIDIBOOL(var, button) inout ? MidiBoolOut(var, button, _midiOut) : MidiBoolIn(var, button, controlId, noteOrCC, value) void GameStage::MidiVars(unsigned int inout, unsigned int noteOrCC, unsigned int controlId, unsigned int value) { if(!_midiOut) return; MIDIVAR(_fogTopColor.x, 0.0f, 1.0f, 1); MIDIVAR(_fogTopColor.y, 0.0f, 1.0f, 2); MIDIVAR(_fogTopColor.z, 0.0f, 1.0f, 3); MIDIVAR(_fogBottomColor.x, 0.0f, 1.0f, 4); MIDIVAR(_fogBottomColor.y, 0.0f, 1.0f, 5); MIDIVAR(_fogBottomColor.z, 0.0f, 1.0f, 6); MIDIVAR(CoCScale, 1.0f, 16.0f, 8); MIDIBOOL(MUSIC, 8); MIDIBOOL(RenderEnvironment, 9); MIDIBOOL(DepthOfField, 10); } Probably not going to win any awards for that, but it does the trick. MidiVars does double duty as an event responder and a full data uploader. MidiSyncOut just includes the PC messages to make sure both layers are fully updated. Although I haven’t done it here, it would be very easy to data drive this, attach variables to MIDI controls from dev console, etc. Once everything’s wired up, you have a completely independent physical display of whatever game values you want, ready to tweak and adjust to your heart’s content at a moment’s notice. If any of you have particularly technically minded designers/artists, they’re probably already using MIDI controllers along with independent glue apps that map them to keyboard keys. Why not cut out the middle man and have explicit engine/tool support? View the full article
  8. I have my own crazy version, built off Boost.Preprocessor for compilers that can't do variadic macros.  This version is cleaner in usage, maybe I'll tweak mine to work similarly.
  9. I’m planning to review this camera properly at some point, but for the time being, I wanted to do a simple test of what the parameters of EVF lag and blackout are. Let’s talk about lag first. What do we mean? The A77 II uses an electronic viewfinder, which means that the viewfinder is a tiny LCD panel, showing a feed of what the imaging sensor currently sees. This view takes camera exposure and white balance into exposure, allowing you to get a feel for what the camera is actually going to record when the shutter fires. However, downloading and processing the sensor data, and then showing it on the LCD, takes time. This shutter firing needs to compensate for this lag; if you hit the shutter at the exact moment an event occurs on screen, the lag is how late you will actually fire the shutter as a result. How do we test the lag? Well, the A77 II’s rear screen shows exactly the same display as the viewfinder, presumably with very similar lag. So all we have to do is point the camera at an external timer, and photograph both the camera and the timer simultaneously. And so that’s exactly what I did. Note that I didn’t test whether any particular camera settings affected the results. The settings are pretty close to defaults. “Live View Display” is set to “Setting Effect ON”. These are the values I got, across 6 shots, in millseconds: 32, 16, 17, 34, 17, 33 = 24.8 ms average I discarded a few values due to illegible screen (mid transition), but you get the picture. The rear LCD, and my monitor, are running at a 60 Hz refresh rate, which means that a new value appears on screen every ~16.67 ms. The lag wobbles between one and two frames, but this is mostly due to the desynchronization of the two screen refresh intervals. It’s not actually possible to measure any finer using this method, unfortunately. However the average value gives us a good ballpark value of effectively 25 ms. Consider that a typical computer LCD screen is already going to be in the 16ms range for lag, and TVs are frequently running in excess of 50ms. This is skirting the bottom of what the fastest humans (pro gamers etc) can detect. Sony’s done a very admirable job of getting the lag under control here. Next up: EVF blackout. What is it? Running the viewfinder is essentially a continuous video processing job for the camera, using the sensor feed. In order to take a photo, the video feed needs to be stopped, the sensor needs to be blanked, the exposure needs to be taken, the shutter needs to be closed, the image downloaded off the sensor into memory, then the shutter must open again and the video feed must be resumed. The view of the camera goes black during this entire process, which can take quite a long time. To test this, I simply took a video of the camera while clicking off a few shots (1/60 shutter) in single shot mode. Here’s a GIFed version at 20 fps: By stepping through the video, I can see how long the screen is black. These are the numbers I got, counted in 60 Hz video frames: 17, 16, 16, 17, 16, 16 = 272 ms average The results here are very consistent; we’ll call it a 0.27 second blackout time. For comparison, Canon claims that the mirror blackout on the Canon 7D is 0.055 seconds, so this represents a substantial difference between the two cameras. It also seems to be somewhat worse than my Panasonic GH4, another EVF based camera, although I haven’t measured it. I think this is an area which Sony needs to do a bit more, and I would love to see a firmware update to try and get this down at least under 200 ms. It’s worth noting that the camera behaves differently in burst mode, going to the infamous “slideshow” effect. At either 8 or 12 fps settings, the screen shows the shot just taken rather than a live feed. This quantization makes “blackout time” slightly meaningless, but it can present a challenge when tracking with erratically moving subjects. View the full article
  10. I was digging through my Ventspace post drafts, and I found this writeup that I apparently decided not to post. It was written in March of 2012, a full year and a half before the Xbox One arrived in the market. In retrospect, I’m apparently awesome. On the one hand, I wish I’d posted this up at the time, because it’s eerily accurate. On the other hand, the guesses are actually accurate enough that this might have looked to Microsoft like a leak, rather than speculation. Oh well. Here it is for your amusement. I haven’t touched a thing about it. I’ve been hearing a lot of rumors, though the credibility of any given information is always suspect. I have some supposed info about the specs on the next Xbox, but I’m not drawing on any of that info here. I’m dubious about at least some of the things I heard, and it’s not good to spill that kind of info if you’re trying to maintain a vaguely positive relationship with a company anyway. So what I’m presenting here is strictly speculation based on extrapolation of what we’ve seen in the past and overall industry and Microsoft trends. I’m also assuming that MS is fairly easy to read and that they’re unlikely to come out of left field here. 8 GB shared memory. The original Xbox had 64 MB of shared memory. The Xbox 360 has 512, a jump of 8x. This generation is dragging along a little longer, and memory prices have dropped violently in the last year or so. I would like to see 16 GB actually, but the consoles always screw us on memory and I just don’t think we’ll be that lucky. 4 GB is clearly too low, they’d be insane to ship a console with that now. As for the memory type, we’re probably talking simple (G)DDR3 shared modules. The Xboxes have always been shared memory and there’s no reason for them to change that now. Expect some weird addressing limitations on the GPU side. Windows 8 kernel. All indications are that the WinCE embedded kernel is being retired over the next two years (at least for internal use). There’s a substantial tech investment in Windows 8, and I think we’re going to see the desktop kernel roll out across all three screens. (HINT HINT.) iOS and Android are both running stripped desktop kernels, and the resources in current mobile platforms make WinXP’s minimum hardware requirements look comically low. There is no reason to carry the embedded kernel along any longer. I wouldn’t want to be a CE licensee right now. x86-64, 8×2 threads, out of order CPU. There are three plausible CPU architectures to choose from: x86, ARM, and PowerPC. Remember what I said about the Windows 8 kernel? There’s no Windows 8 PPC build, and we’re not going to see PowerPC again here. ARM is of course a big focus right now, but the design parameters of the current chips simply won’t accommodate a console. They’re not fast enough and that can’t be easily revised. That pretty much leaves us with x86. The only extant in-order x86 architecture is Intel Atom, which sucks. I think they’ll get out of order for free from the existing architectures. As far as the CPU, 8 core is essentially the top of the market right now, and I’m assuming they’ll hyperthread it. They’ll probably steal a core away from the OS, and I wouldn’t be surprised if they disable another core for yield purposes. That means six HT cores, which is a simple doubling of the current Xbox. I have a rumored clock-speed, but have decided not to share. Think lower rather than higher. DirectX 11 GPU — AMD? DX11 class should be blatantly obvious. I have reason to believe that AMD is the supplier, and I did hear a specific arch but I don’t believe it. There’s no word in NVIDIA land about a potential contract, either. No idea if they’re giving the design ownership to MS again or anything like that, all I know is the arrows are all pointed the same way. There are some implications for the CPU here. Wifi N and Gigabit ethernet. This is boring standard consumer networking hardware. No surprises here. Optical drive? — I don’t think they want to have one. I do think they have to have one, though you can definitely expect a stronger push towards digital distribution than ever. There’s no choice but to support Blu-ray at this point. Top tier games simply need the space. I suspect that we’ll see a very large (laptop grade) hard drive included in at least some models. Half terabyte large, with larger sizes later in the lifecycle. That is purely a guess, though. AMD Fusion APU? — I’m going to outlandishly suggest that a Fusion APU could be the heart of this console. With an x86 CPU and a mainstream Radeon core in about the right generation, the existing Fusion product could be retooled for use in a console. Why not? It already has the basic properties you want in a console chip. The big sticking points are performance and heat. It’s easy to solve either one but not both at once, and we all know what happened last time Microsoft pushed the heat envelope too far. If it is Fusion architecture, I would be shocked if they were to actually integrate the CPU and GPU dies. Kinect. — Here’s another outlandish one: Every Xbox Next will include a Kinect (2?), in the box. Kinect has been an enormous winner for Microsoft so far on every single front, and this is where they’re going to draw the battle lines against Nintendo and Sony. Nintendo’s control scheme is now boring to the general public, with the Wii U being introduced to a resounding “meh”. PS Move faded into irrelevance the day it was launched. For the first time in many years, the Xbox is becoming the casual gamers’ console and they’re going to hammer that advantage relentlessly. Microsoft is also pushing use of secondary features (eg microphone) for hardcore games — see Mass Effect 3. $500. Yes, it’s high, although not very high once you adjust for inflation. The Xbox 360 is an extremely capable device, especially for the no-so-serious crowd. It’s also pure profit for Microsoft, and really hitting its stride now as the general public’s long tail console. There’s no need to price its successor aggressively, and the stuff I just described is rather expensive besides. A $600 package option at launch would not be surprising. November 2013. As with the last two Xboxes, it will be launched for the holiday season. Some people were saying it would be announced this year but the more I think about it, the less it makes sense to do so. There’s no way it’s launching this year, and they’re not going to announce it a year and some ahead of time. E3 2013 will probably be the real fun. There are some problems with the specs I’ve listed so far. AMD doesn’t produce the CPU I described. Not that the rumors match any other known CPU, but Intel is closer. I don’t think one of the Phenom X6 designs is a credible choice. The Xbox 360 CPU didn’t match any existing chips either, so this may not really be a problem. The total package price would have to be quite high with a Kinect 2 included. The Xbox 360 may function as a useful buffer against being priced out of the market. View the full article
  11. Some of you are probably working on Retina support and performance for your OpenGL based game for iOS devices. If you’re like us, you’re probably finding that a few of the devices (*cough* iPad 3) don’t quiiite have the GPU horsepower to drive your fancy graphics at retina resolutions. So now you’re stuck with 1x and 4x MSAA, which performs decently well but frankly looks kind of bad. It’s a drastic step down in visual fidelity, especially with all the alpha blend stuff that doesn’t antialias. (Text!) Well it turns out you don’t have to choose such a drastic step. Here’s the typical enable-retina code you’ll find on StackOverflow or whatever: if([[UIScreen mainScreen] respondsToSelector:@selector(scale)] && [[UIScreen mainScreen] scale] == 2) { self.contentScaleFactor = 2.0; eaglLayer.contentsScale = 2.0; } //some GL setup stuff ... //get the correct backing framebuffer size int fbWidth, fbHeight; glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &fbWidth); glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, &fbHeight); The respondsToSelector bit is pretty token nowadays – what was that, iOS 3? But there’s not much to it. Is the screen a 2x scaled screen? Great, set our view to 2x scale also. Boom, retina. Then we ask the GL runtime what we are running at, and set everything up from there. The trouble is it’s a very drastic increase in resolution, and many of the early retina devices don’t have the GPU horsepower to really do nice rendering. The pleasant surprise is, the scale doesn’t have to be 2.0. Running just a tiny bit short on fill? if([[UIScreen mainScreen] respondsToSelector:@selector(scale)] && [[UIScreen mainScreen] scale] == 2) { self.contentScaleFactor = 1.8; eaglLayer.contentsScale = 1.8; } Now once you create the render buffers for your game, they’ll appear at 1.8x resolution in each each direction, which is very slightly softer than 2.0 but much, much crisper than 1.0. I waited until after I Am Dolphin cleared the Apple App Store approval process, to make sure that they wouldn’t red flag this usage. Now that it’s out, I feel fairly comfortable sharing it. This can also be layered with multisampling (which I’m also doing) to fine tune the look of poly edges that would otherwise give away the trick. I use this technique to get high resolution, high quality sharp rendering at 60 fps across the entire range of Apple devices, from the lowly iPhone 4S, iPod 5, and iPad 3 on up. View the full article
  12. I’d hoped to write up a nice post for this, but unfortunately I haven’t had much time lately. Releasing a game, it turns out, is not at all relaxing. Work doesn’t end when you hit that submit button to Apple. In the meantime, I happened to put together a video showing a prototype of the game, running off Kinect control. I thought you all might find it interesting, as it’s a somewhat different control than the touch screen. Personally I think it’s the best version of the experience we’ve made, and we’ve had several (touch screen, mouse, PS Move, Leap, etc). Unlike the touch screen version, you get full 3D directional control. We don’t have to infer your motion intention. This makes a big difference in the feeling of total immersion. View the full article
  13. Promit

    Our New Game: I Am Dolphin

    After an incredibly long time of quiet development, our new game, I Am Dolphin, will be available this Thursday, October 9th, on the Apple/iOS App Store. This post will be discussing the background and the game itself; I’m planning to post more technical information about the game and development in the future. This depends somewhat on people reading and commenting – tell me what you want to know about the work and I’m happy to answer as much as I can. For those of you who may not have followed my career path over time: A close friend and I have spent quite a few years doing R&D with purely physically driven animation. There’s plenty of work out there on the subject; ours is not based on any of it and takes a completely different approach. About three years ago, we met a neurologist at the Johns Hopkins Hospital who helped us set up a small research group at Hopkins to study biological motion and create a completely new simulation system from the ground up, based around neurological principles and hands-on study of dolphins at the National Aquarium in Baltimore. Unlike many other physical animation systems, including our own previous work, the new work allows the physical simulation to be controlled as a player character. We also developed a new custom in-house framework, called the Kata Engine, to make the simulation work possible. One of the goals in developing this controllable simulation was to learn more about human motor control, and specifically to investigate how to apply this technology to recovery from motor impairments such as stroke. National Geographic was kind enough to write some great articles on our motivations and approach: Virtual Dolphin On A Mission John Krakauer’s Stroke of Genius Although the primary application of our work is medical and scientific, we’ve also spent our spare time to create a game company, Max And Haley LLC, and a purely entertainment focused version of the game. This is the version that will be publicly available in a scant few days. Here is a review of the game by AppUnwrapper. I got my hands on the beta version of the game, and it’s incredibly impressive and addictive. I spent two hours playing right off the bat without even realizing it, and have put in quite a few more hours since. I just keep wanting to come back to it. iPhones and iPads are the perfect platform for the game, because they allow for close and personal, tactile controls via simple swipes across the screen. I now have three shipped titles to my name; I’d say this is the first one I’m really personally proud of. It’s my firm belief that we’ve created something that is completely unique in the gaming world, without being a gimmick. Every creature is a complete physical simulation. The dolphins you control respond to your swipes, not by playing pre-computed animation sequences but by actually incorporating your inputs into the drive parameters of the underlying simulation. The end result is a game that represents actual motion control, not gesture-recognition based selection of pre-existing motions. As I said at the beginning of the post, this is mostly a promotional announcement. However, this is meant to be a technical blog, not my promotional mouthpiece. I want to dig in a lot to the actual development and technical aspects of this game. There’s a lot to talk about in the course of developing a game with a three person (2x coder, 1x artist) team, building a complete cross-platform engine from nothing, all in the backdrop of an academic research hospital environment. Then there’s the actual development of the simulation, which included a lot of interaction with the dolphins, the trainers, and the Aquarium staff. We did a lot of filming (but no motion capture!) in the course of the development as well; I’m hoping to share some of that footage moving forward. Here’s a slightly older trailer – excuse the wrong launch date on this version. We decided to slip the release by two months after this was created – that’s worth a story in itself. It is not fully representative of the final product, but our final media isn’t quite ready. View the full article
  14. I’ve been in the process of building and testing a new machine using Intel’s new X99 platform. This platform, combined with the new Haswell-E series of CPUs, is the new high end of what Intel is offering in the consumer space. One of the pain points for developers is build time. For our part, we’re building in the general vicinity of 400K LOC of C++ code, some of which is fairly complex — it uses standard library and boost headers, as well as some custom template stuff that is not simple to compile. The worst case is my five year old home machine, an i5-750 compiling to a single magnetic drive, which turns in a six minute full rebuild time. Certainly not the biggest project ever, but a pretty good testbed and real production code. I wanted to find out what storage system layout would provide the best results. Traditionally game developers used RAID 0 magnetic arrays for development, but large capacity SSDs have now become common and inexpensive enough to entertain seriously for development use. I tested builds on three different volumes: A single Samsung 850 Pro 512 GB (boot) A RAID 0 of two Crucial MX100 512 GB A RAID 0 of three WD Black 4 TB (7200 rpm) Both RAID setups were blank. The CPU is an i7-5930k hex-core (12 threads) and I’ve got 32 GB of memory on board. Current pricing for all of these storage configurations is broadly similar. Now then, the results. Will the Samsung drive justify its high price tag? Will the massive bandwidth of two striped SSDs scream past the competitors? Can the huge magnetic drives really compete with the pinnacle of solid state technology? Who will win? Drumroll… They’re all the same. All three configurations run my test build in roughly 45 seconds, the differences between them being largely negligible. In fact it’s the WD Blacks that posted the fastest time at 42s. The obvious takeaway is that all of these setups are past the threshold where something else is the bottleneck. That something in this case is the CPU, and more specifically the overall hardware thread count. Overclocking the CPU from 3.5 to 4.5 did nothing to help. I’ve heard of some studios outfitting their engineers with dual Xeon setups, and it’s not looking so crazy to do so when employee time is on the line. (The potential downside is that the machine starts to stray significantly from what the game will actually run on.) Given the results, and the sizes of modern game projects, I’d recommend using an inexpensive 500 GB SSD for a boot drive (Crucial MX100, Sandisk Ultra II, 840 EVO), and stocking up on the WD Blacks for data. Case closed. But… as long as we’re here, why don’t we take a look at what these drives are benchmarking at? The 850 Pro is a monster of a drive. Those striped MX100s might be the real heros though; ATTO shows them flirting with a full gigabyte per second of sequential transfer. Here are the raw CrystalDiskMark numbers for all three: Samsung 850 Pro: Sequential Read : 520.557 MB/s Sequential Write : 489.836 MB/s Random Read 512KB : 407.993 MB/s Random Write 512KB : 465.648 MB/s Random Read 4KB (QD=1) : 24.216 MB/s [ 5912.1 IOPS] Random Write 4KB (QD=1) : 71.216 MB/s [ 17386.7 IOPS] Random Read 4KB (QD=32) : 398.378 MB/s [ 97260.3 IOPS] Random Write 4KB (QD=32) : 331.571 MB/s [ 80950.0 IOPS] 2x Crucial MX100 in RAID 0: Sequential Read : 898.908 MB/s Sequential Write : 905.506 MB/s Random Read 512KB : 695.787 MB/s Random Write 512KB : 854.666 MB/s Random Read 4KB (QD=1) : 26.271 MB/s [ 6413.8 IOPS] Random Write 4KB (QD=1) : 110.554 MB/s [ 26990.8 IOPS] Random Read 4KB (QD=32) : 430.077 MB/s [104999.3 IOPS] Random Write 4KB (QD=32) : 413.606 MB/s [100978.0 IOPS] 3x WD Black 4TB in RAID 0: Sequential Read : 530.522 MB/s Sequential Write : 494.534 MB/s Random Read 512KB : 61.752 MB/s Random Write 512KB : 162.619 MB/s Random Read 4KB (QD=1) : 0.724 MB/s [ 176.7 IOPS] Random Write 4KB (QD=1) : 4.461 MB/s [ 1089.1 IOPS] Random Read 4KB (QD=32) : 5.090 MB/s [ 1242.8 IOPS] Random Write 4KB (QD=32) : 5.307 MB/s [ 1295.6 IOPS] I don’t claim that these numbers are reliable or representative. I am only posting them to provide a general sense of the performance characteristics involved in each choice. The SSDs decimate the magnetic drive setup for random ops, though the 512 KB values are respectable. I had expected the 4K random read, for which SSDs are known, to have a significant impact on build time, but that clearly isn’t the case. The WDs are able to dispatch 177 of those per second; despite being 33x slower than the 850 Pro, this is still significantly faster than the compiler can keep up with. Even in the best case scenarios, a C++ compiler won’t be able to clear out more than a couple dozen files a second. View the full article
  15. It’s good to review the fundamentals sometimes. Written in 1995 and often forgotten: A Pixel Is Not A Little Square. View the full article
  • Advertisement

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!