Sundog Software

SilverLining featured in June issue of Develop

Frank Kane — Sat, 12 Jun 2010 20:49:03 +0000

SilverLining is featured in this month’s issue of Develop, the popular UK-based game development magazine. You’ll find us in the middleware feature; in addition to our half-page ad, we’re also featured in the section on “specialized middleware,” and quotes from Sundog Software’s founder, Frank Kane, are sprinkled throughout the feature. You can read it online for free - check it out! (And consider subscribing, it’s a nice magazine.)

A big welcome to our European visitors checking us out from the article, and thanks to Vizerra for helping us out with the screenshots featured in it!

OpenGL 3.2+ support, less memory, and no more popping clouds

Frank Kane — Mon, 07 Jun 2010 22:08:25 +0000

We just released version 1.971 of SilverLining, featuring support for OpenGL 3.2 core contexts, new features to blend clouds into the sky better and eliminate popping, much better memory usage, visual enhancements, and bug fixes. Go get it from our download page.

The new SilverLiningOpenGL32 renderer supports “core contexts” for OpenGL 3 that do not support backward compatibility. This new renderer completely eliminates the fixed-function pipeline for OpenGL, and only uses core functions in the OpenGL 3.2 specification plus certain extensions if they are present. We continue to support the SilverLiningOpenGL renderer which runs on anything going back to OpenGL 1.4. See the new OPENGL32CORE option in Atmosphere::Initialize, as well as the new OpenGL 3.2 sample project included in the new SDK.

SilverLining 1.971 also includes new methods you can use to fade clouds out with distance, making them blend seamlessly into the sky. If you’re upgrading from an earlier version, you’ll want to pay closer attention to the value you pass into AtmosphericConditions::SetVisibility(), and clouds now fade out as they approach this distance. If SetVisibility() is set too low, your clouds may look too fuzzy and ephemeral.

We’ve also introduced two new methods on the CloudLayer object. CloudLayer::SetCloudWrapping() may now be used to create cloud layers that remain in the same position regardless of wind positions. Like infinite cloud layer types, the clouds in these layers will wrap around the layer as they reach the edge of the layer’s bounds. But unlike infinite cloud layers, these layers are localized and don’t follow the camera around.

In order to hide the popping that occurs when a cloud wraps around a layer in infinite cloud layers or in wrapping cloud layers, we’ve also introduced CloudLayer::SetFadeTowardEdges(). You can use this method to enforce fading clouds out as they approach an edge of the layer, ensuring that pops are never visible.

1.971 also includes better support for large cloud layers on round-Earth models. Cumulus and cirrocumulus cloud layer types will now conform to the curvature of the Earth, in addition to stratus and cirrus cloud layers.

You’ll also find that SilverLining uses much less memory with this revision – the overhead associated with each cloud voxel has been reduced substantially, and even more so on 64-bit builds. This reduced memory consumption can translate to better performance as well.

There are also several bug fixes and visual enhancements to be found in this new version. Grab the new evaluation SDK here, and registered users may download the full version free of charge from the same location you originally obtained it from. As always, feedback and bug reports are welcome at support@sundog-soft.com.

Vizerra writes about collaboration with Sundog

Frank Kane — Sat, 05 Jun 2010 17:48:09 +0000

We owe a debt of gratitude to one of our customers, 3DreamTeam, makers of Vizerra. During the development of Vizerra, we worked closely together to help refine the look of SilverLining to match the realism of their virtual landmark tours. The results of this collaboration were dramatic.

They’ve posted an article on their blog about it, with some interesting “before” and “after” screenshots that show you just how far SilverLining has come along over the years. Check it out, and give Vizerra a download - its graphics really are jaw-dropping.

Visual C++ 2010 support

Frank Kane — Fri, 16 Apr 2010 22:47:37 +0000

Version 1.963 of SilverLining now includes libraries, samples, and project files for Microsoft’s new release of Visual C++ 2010. You’ll find the new libraries under the lib/vc10 directory of the SDK, alongside the libraries for Visual C++ 6.0 (vc6), Visual Studio .NET 2003 (vc7), Visual Studio 2005 (vc8), Visual Studio 2008 (vc9), and GCC for Linux and MacOS – all of which we’ll continue to support.

Third-party dependencies eliminated

Frank Kane — Mon, 12 Apr 2010 16:29:16 +0000

Version 1.962 of SilverLining, available now from our download page, eliminates all third-party DLL dependencies. This simplifies the distribution of an app linked with SilverLining, and gets you up and running that much faster when doing an initial integration.

We no longer link against NVidia’s Cg Toolkit libraries, instead using GLSL or HLSL directly and falling back to fixed-function pipeline functionality on older drivers that do no support these shader technologies. We’ve also stopped linking against GLUT in our OpenGL renderer, which was a common source of DLL conflicts when people had different versions of GLUT installed on their systems.

This latest revision also includes a few bug fixes specific to stratus clouds; updating is recommended if you’re using stratus clouds under OpenGL on ATI cards, or if you’re using stratus clouds with coverage less than 1.0 under DirectX9.

SilverLining: Playing Nice With Others

Frank Kane — Wed, 31 Mar 2010 02:23:42 +0000

SilverLining 1.96 is now available from our download page. This release makes it easier to integrate SilverLining with existing game engines, by abstracting away its asset management and memory management. Combined with our existing support for plugging in new renderers and a highly portable cross-platform code base, SilverLining is now more versatile than ever.

One thing you’ll notice is the new ResourceLoader class. Our default ResourceLoader assumes a POSIX filesystem and reads our textures, shaders, and data files directly from the resources directory you specify when calling Atmosphere::Initialize(). However, you may extend this class to load assets in any way you wish – from your own pack files, your own versions of our assets optimized for a given platform or media type, compressed files, etc. Just pass a pointer to your own implementation of ResourceLoader to Atmosphere::SetResourceLoader() before calling Atmosphere::Initialize(), and all disk access will be routed through the ResourceLoader class you provide. (Note – remember our renderer DLL’s are also in the resources directory, and you’ll need to deal with those seperately. You can always eliminate the DLL’s altogether by statically linking in the one you need, if you’re a licensed customer armed with the full source.)

We’ve also gone through and replaced all of SilverLining’s calls to new, delete, malloc, and free with the macros SL_NEW, SL_DELETE, SL_MALLOC, and SL_FREE. Licensed users with full source may redirect these operators to their own memory manager by redefining them in the header SilverLiningTypes.h, and recompiling our libraries and DLL’s.

And, remember you can also tie in your own renderer directly into SilverLining if our built-in support for DirectX 9, 10, 11, or OpenGL doesn’t meet your needs. In this mode of operation, you can essentially treat SilverLining as a numerical engine that calls back into your own methods for allocating vertex buffers, setting textures and shaders, and rendering triangle strips and points.

If there are more ways we can help tie SilverLining seamlessly into the engine you’re using, always feel free to let us know!

Serialization Support, Better DirectX9 Support, New Lightspeed Integration.

Frank Kane — Tue, 16 Mar 2010 04:24:28 +0000

Version 1.952 of SilverLining is now available from our download page. This new revision adds the methods Atmosphere::Serialize() and Atmosphere::Unserialize(), which you can use to save and restore SilverLining’s complete state to any STL iostream. This is particularly handy not just for saving conditions to disk, but for handling device reset events in Direct3D 9 – when you lose the device, you need to delete and re-create the Atmosphere object, and these methods make doing so a lot easier.

There are other improvements for DirectX9 in version 1.952 as well – we fixed a few bugs that manifested themselves when using the debug runtime, and eliminated the warnings about pixel read-back on surfaces without lockable backbuffers coming from our Glare class when glares are disabled (which they are by default.) In 1.952, the fixed function pipeline is no longer used at all under DirectX 9, which allows us to avoid a lot of problems. This version also restores compatibility with older video cards that only support Shader Model 2.0.

We’ve also got a new version of the SilverLining / Gamebryo Lightspeed integration available both here on our website, and on http://pulse.emergent.net. This new integration supports Lightspeed version 3.1.1, and includes bug fixes as well as new dimmers for the ambient, specular, and diffuse components of the SilverLiningDirectionalLight entity model.

As always, let us know if you have any trouble with this new release, or if you have ideas for new enhancements to SilverLining.

We’re in Game Engine Gems

Frank Kane — Thu, 11 Mar 2010 03:47:30 +0000

Sundog Software has authored two chapters in the new book “Game Engine Gems” – “Physically Based Outdoor Scene Lighting” and “Physically Realistic Skyboxes”. If you’re at GDC, you can get a sneak peek at it at booth #1843! Order one now from Amazon.com.

If you’re curious about how SilverLining works under the hood, these chapters provide some of the theory behind how we do our lighting, tone mapping, and computation of skybox colors. It’s chock full of other useful tips and techniques for game engine developers as well.

Now supporting HDR, GLSL, lens flare, and more

Frank Kane — Sun, 14 Feb 2010 20:53:01 +0000

SilverLining 1.95 is now available from our download page. This new version has much better support for high-dynamic range applications – you can now toggle HDR mode at runtime using Atmosphere::EnableHDR(). This will disable all tone mapping and gamma correction, and draw to your floating point framebuffer in raw units of kilo-candelas per square meter with 128 bits of color precision. We’ve also introduced a lens flare effect, support for legacy compilers (Visual C 6.0 and Visual Studio .NET 2003), visual quality improvements, and bug fixes. We’ve also moved to GLSL shaders from Cg for OpenGL developers, which improves our compatibility with ATI hardware. For DirectX developers, we’re now linking against the August 2009 DirectX SDK.

Direct Integration with Custom Renderers

Frank Kane — Fri, 15 Jan 2010 02:58:23 +0000

SilverLining 1.94 includes a new “custom renderer” sample project, illustrating how to tie SilverLining into your own rendering engine directly. You no longer need to let SilverLining render directly via OpenGL or DirectX; you can wire our drawing calls directly into any engine you’d like now. This opens up possibilities such as using SilverLining as a numerical engine on console platforms.

All of the platform-specific code for OpenGL or DirectX in SilverLining is isolated into renderer code that may be loaded dynamically at runtime. This means the core of SilverLining is platform-agnostic; you may substitute our renderer implementations for your own, and tie SilverLining directly into your own rendering engine. Licensed users receive the full source of SilverLining, which essentially means you can use SilverLining on any system with a C++ compiler with STL, such as gaming consoles.
In this mode, you can essentially think of SilverLining as a numerical engine that calls back into your own renderer to do the actual drawing, texture loading, setup of vertex buffers, etc.

Bear in mind that if your rendering engine is built on top of OpenGL or DirectX, it’s easier to use SilverLining’s native support of OpenGL or DirectX. Even though it’s going “behind the back” of your engine to render directly at a lower level, you don’t need to worry about SilverLining interfering with your engine. We’re careful to restore any state that was set prior to calling SilverLining API’s, and since we do our drawing at the very beginning and very end of the scene surrounding your own frame update code, our drawing stays out of the way of the rest of your scene. Our sample integration code for OpenSceneGraph, Gamebryo Lightspeed, and Ogre3D all work in this manner without any problems.

However, if you’re using SilverLining on a system that’s not built on standard OpenGL or DirectX (such as Playstation, Wii, or XBox,) you’ll need to implement hooks into your system’s renderer. We provide sample code to get you started.

If you’re tying into your own renderer, use the “static” version of the SilverLining libraries (for example, lib/vc9/win32/SilverLining-MT-static.lib/) These libraries do not attempt to dynamically load a renderer at runtime, and do not include any rendering code of their own. You then need to implement all of the functions defined in the header file “SilverLiningDLLCommon.h.” SilverLining is able to operate with some of these functions stubbed out; the comments indicate when this is the case. Essentially, you need to provide hooks for loading and activating shaders, vertex buffers, index buffers, and textures, as well as code to draw triangle strips and lists of points using these resources. When initializing your Atmosphere object, pass in CUSTOM_RENDERER as the renderer type.

The SampleCode/CustomerRendererExample folder contains a project that illustrates how to tie SilverLining into your own renderer – in this case, it ties it back into DirectX9 directly. It’s similar to our DX9 sample code, but implements its own DirectX9 renderer that you could swap out with any other renderer instead. Licensed users may also examine the source of our native OpenGL, DirectX9, DirectX10, and DirectX11 renderers as further examples. If you’re evaluating SilverLining and need one of these other renderers as a starting point for your own integration, drop a note to support@sundog-soft.com and we’ll be glad to help.

Don’t be intimidated by the amount of code in our sample DirectX9 renderer – a good portion of the functions actually aren’t required for SilverLining to run (see the comments in SilverLiningDLLCommon.h for guidance,) and you can likely implement the required functions in far fewer lines of code when you’re coding against a rendering engine that abstracts away the complexity of DirectX or OpenGL.