Complex 3D data on all devices

Virtual Reality - Science Daily - 6 February 2017 - 5:41am
A new web-based software platform is swiftly bringing the visualization of 3D data to every device, optimizing the use of, for example, virtual reality and augmented reality in industry. In this way, researchers have brought the ideal of “any data on any device” a good deal closer.
Categories: Virtual Reality

ThinkShout: The 2017 ThinkShout Front-End Stack

Planet Drupal - 6 February 2017 - 5:00am

Front-end development is full of challenges - changing design trends, browser idiosyncrasies, client demands, and ever-evolving web standards to name a few. Over the last few years though, a new challenge has emerged. Which development stack should you choose?

Once upon a time, front end development didn’t really have a “dev stack.” You had markup in files, maybe output from a CMS, a stylesheet, and some jQuery if you felt like getting fancy. Now though, the array of options can be paralysing. Pre-processors, post-processors, task runners, and package managers have made many aspects of development faster, but which ones are best? Where do you start?

Here at ThinkShout, under the watchful eye of Eric Paxton, our Senior Front End Engineer, we’ve been trying out the various options whenever we take on a new project, to see how well it fits in our theming process. We’re pretty busy, so this covers a lot of ground quickly. We’ve been careful to fully document the tools used in the past so that we don’t bedevil the maintenance folks. (We are often the maintenance folks).

The last few builds have seen our dev stack settle down to a flexible tool set that is easy to setup and maintain, while providing us with excellent modern theming tools. Let’s dive in!

Getting Started: Languages, Handlers, and Package Management

At the bottom of a development stack are the languages used, the language handlers, and the package managers that allow you to include pre-built tools and libraries in your project. Some of these are interchangeable, but it solves a lot of problems if everyone uses the same fundamental tools.

In our case, we use Ruby and JavaScript as the base languages, and rbenv and Node as their handlers. By using Ruby and JavaScript, we get access to an extremely wide array of applications, tools, plugins, and more. Once these are installed (Using an OS package manager! In this case, Homebrew (since we all use Macs), we add package handling for these languages: Bundler and NPM respectively. This gives us the following base:

  • Ruby via rbenv, managing gems using Bundler
  • JavaScript via Node.js, managing packages using NPM

Now we can specify Ruby Gems and Node packages in a Ruby Make file (Rakefile), and a complex project setup is as simple as running rake install once from the theme directory, and starting the task watcher using rake serve. (To be more precise, we use the Rakefile to install the Ruby Gems as defined in the Gemfile, and the Node modules as specified in the package.json file).

The complete project setup for a new developer would be the following:

~: brew install rbenv ~: gem install bundler ~: brew install node ~: brew install npm; ~: cd ~/path/to/theme/directory ~: rake install ~: rake serve

After that, any new projects would only need the last three lines run.

The key to making this work is to have a Rakefile, a Gemfile and a package.json set up in our project’s theme so that rake install works properly. In our case we use the Rakefile to first run bundle install, which installs the appropriate gems and their dependencies:


task :install do system 'bundle install' // this runs the Gemfile contents! system 'npm install -g browser-sync' end


source '' gem 'sass' gem 'sass-globbing'

This generates a Gemfile.lock listing all of the installed packages/versions.

The npm install lines in the Rakefile setup tools that we’ll discuss later. Our next layer in the stack are the SASS tools that Bundler installed.

SASS at ThinkShout (please pass the Bourbon)

In the middle of our stack is [SASS]( We use SASS in a fairly simple way at ThinkShout, installing it with [sass-globbing]( This allows us to set up directories that allow any files using the appropriate _filename.scss syntax to be included in the build. We also tend to keep the directory structure fairly minimal:


@import 'lib/bourbon/bourbon'; @import 'lib/neat/neat'; @import 'lib/normalize/normalize'; @import 'global/*'; @import 'layout/*'; @import 'modules/*';

The first thing we include is the Bourbon mixin library. This includes coding shortcuts such as the pixels-to-rems syntax rem(24). This allows us to read a design’s pixel spacing and it converts them to the appropriate rem values. The Bourbon Docs are excellent and well-maintained as well. Never worry about browser prefixes or fallbacks again.

Next up is the Bourbon-related grid framework, [Neat]( A simple but powerful grid that uses semantic markup and easy-to-read terminology such as @include span-columns(9). No extra wrappers, no specific classes to add, and it’s extremely robust. We haven’t run into any cross-browser issues in over two years of using it, which says a lot, and since it’s only applied as you specify, it’s easy to break out of the grid if you need to.

Next up is [normalize.css](, a modern update to the old CSS reset stylesheets. Not really much to add to that except it’s really well commented, so make sure you change it from normalize.css to _normalize.scss so that you don’t bloat your final site.css file.

The Global directory has the following:

_01.vars.scss _02.mixins.scss _03.extends.scss _04.base.scss

The _01, _02, etc. prefixes take advantage of the sass-globbing’s alphabetical file inclusion. All our site variables (colors, font weights, and so forth) are in vars, our custom mixins are next, then extends. Base has all of the base markup styles:

body { font-size: rem(16); font-style: normal; font-weight: $regular; -webkit-font-smoothing: antialiased; -moz-osx-font-smoothing: grayscale; } h1, h2, h3, h4, h5, h6 { text-rendering: optimizeLegibility; // Fix the character spacing for headings } p, a, ul, ol, etc...

The layouts directory usually has a _layouts.scss file, which covers the basics of site layout. Since we use Drupal, we’ll often add a _regions.scss as well to specify layout for the various Drupal-generated content zones on a site. These files are where we use the Neat framework the most.

Finally, we have the modules directory - where most of the theming takes place. These are usually named by content type (_basic-pages.scss, _articles.scss, etc.), though there are often files such as _forms.scss and _homepage.scss as well. Sometimes we don’t even have to use our source maps to know where code is!

One of our good habits is to start with our mobile-first, responsive _01.template.scss file:

// Default / Mobile // Tablet (580px) @media all and (min-width: $tablet) { } // Large Tablet (768px) @media all and (min-width: $lg-tablet) { } // Desktop (1228px) $max-width: 1440px @media all and (min-width: $desktop) { }

When you want to add another theming module, you just make a copy of the template and your progressive breakpoints are included! (The $max-width: 1440px is there in a comment because it’s handy).

All of this gets handled by a task in our Rakefile, which sets a watcher for changes to any SASS file and compiles them into a single css/style.css:

desc 'Watch sass' task :sasswatch do system 'sass -r sass-globbing --watch sass/style.scss:css/style.css' end Pulling It All Together: Browsersync!

Finally, at the top of our stack, we have Browsersync. Eric Paxton, our Senior Front End Engineer, wrote an excellent overview of why we use this amazing tool, what it does, as well as how to install it in detail for Drupal 8.

In our stack it’s as simple as another task in that Rakefile:

desc 'Running Browsersync' task :browsersync do system 'browser-sync start --proxy "" --files "css/*.css" --no-inject-changes' end

And adding the following (generated by running browser-sync start) to the site’s <head> :

<!-- <script id="__bs_script__"> //<![CDATA[ document.write("<script async src='http://HOST:3000/browser-sync/browser-sync-client.2.12.3.js'><\/script>".replace("HOST", location.hostname)); //]]> </script> -->

This also sets a watcher on the CSS, and refreshes every browser you have open to localhost:3000 or the local network IP address it generates upon running rake serve.

The last part of the Rakefile implements the tasks we set up:

desc 'Serve' task :serve do threads = [] %w{sasswatch browsersync}.each do |task| threads << do |devtask| Rake::Task[devtask].invoke end end threads.each {|thread| thread.join} puts threads end

This has the magical effect of opening a new browser window to localhost:3000 when you run rake serve, and reloading it every time you save any of your SASS files. It also scrolls all open windows together, even when you open up things on your phone using the local network proxy, which it helpfully provides as output:

>>> Sass is watching for changes. Press Ctrl-C to stop. [BS] Proxying: [BS] Access URLs: ------------------------------------- Local: http://localhost:3000 External: ------------------------------------- UI: http://localhost:3001 UI External: ------------------------------------- [BS] Watching files... [BS] File changed: css/style.css write css/style.css write css/

This is really the cherry on top of the dev stack - after using it for a little while, you’ll wonder how you ever got along reloading everything manually.

Stack Overview

In summary, here’s that front-end stack:

  • Ruby via rbenv, managing gems using Bundler
  • JavaScript via Node.js, managing packages using NPM
  • SASS with globbing, set up in a simple directory structure
  • Bourbon Mixin library
  • Neat Grid system
  • Normalize.css as _normalize.scss
  • A simple module template containing responsive breakpoints
  • Browsersync

None of this is carved in stone of course, and it gets slightly tweaked for every new build based on the project requirements, such as internationalization, the base CMS (Drupal, WordPress, or Jekyl in our case), and the desire to try out something new, which is fairly constant. After all, that’s how we got to the stack we have today!

Categories: Drupal

Game Developers Conference - seven new things you’ll love in 2017! - by Simon Carless Blogs - 6 February 2017 - 4:17am
As we’re getting ready to put on Game Developers Conference once more, thought it might be a good opportunity, as a co-organizer, to point out some of the new things we’re doing this year.
Categories: Game Theory & Design

Janez Urevc: Possible solution for knowledge sharing in the Drupal 8 media domain

Planet Drupal - 6 February 2017 - 1:48am
Possible solution for knowledge sharing in the Drupal 8 media domain slashrsm Mon, 06.02.2017 - 10:48

Drupal 8 has very good media handling support. Media team has (and still is) working hard to make Drupal the best CMS in the world when it comes to managing media. We have many modules in the contrib space that solve most of the common use cases in the domain. There is one problem though; there are many of them and some of them are quite complex and abstract. I've noticed that many times users struggle to completely understand what each module is responsible for, which features it comes with and specially how they all together fit into the bigger picture.

There are so-called feature modules (such as File entity browser, Media, Content browser, Media entity browser, ...) and distributions (such as NP8, Thunder, Lightning, ...) which ship with default configuration for the 80% use case. They are plug and play solutions, but it is also possible to use them as a base for learning and research of the ecosystem.

But unfortunately that's not enough. While some people learn the quickest by exploring existing solutions (myself included) that isn't the case for everyone. A lot of people need more guidance and those are the users that we're currently not supporting as much as we should. In order to drive further adoption of the media ecosystem and Drupal 8 itself we need to solve this knowledge sharing problem that I believe we have.

I was thinking about this problem a lot lately and I think I came up with an idea that could help us solve it.

It is a book.

A problem solving oriented book which would guide users through the ecosystem, explain individual parts and, most importantly, offer a bunch of recipes for the common problems. It wouldn't be one of those 800+ pages technical books (who has time to read that?!). Rather it would be a compact source of information which you can have on your desk and use it when you run into a problem. We all want to build websites and the purpose of this book would be to help you do that as fast and as efficiently as possible.

Book would produced by the people that designed and built the Drupal 8 media ecosystem, which would ensure highest levels of quality. It would be released under a Creative commons license with its sources publicly available on GitHub. Printed and compiled eBook versions would be sold through the standard channels.

Why copyleft?

I honestly believe into the free sharing of knowledge in our society. My opinion is that the only way to evolve our civilization is to freely share the knowledge that we have. There are also practical reasons besides the philosophical one. Making the book publicly available ensures that it will be likely updated as the ecosystem and Drupal itself evolve and change. This wouldn't necessarily be the case if the standard copyright license would be used.

Great idea! Why didn't you realize it already?

I am glad that you agree! :) Well... it is not that easy. Producing a real book is not that simple and it also comes with quite some expenses. There is the cost of the content production, proofreading, design, print, shipping, ... I've done a back of a napkin calculation and estimated that we'd need around 20.000€/$21.500/17.000GBP to do it.

My idea was to start a crowdfunding campaign to raise this amount. Backers would, depending on the perk level, get an eBook, print edition or both. Besides that they'd also get early access to the repository with the ability to provide feedback during the process of writing.

Now I need your feedback

I need to hear from you. Is this something that would benefit the community? Is there any better way to educate users about the ecosystem? Would you prefer an online video course instead of a book? In-person training? Something else? Would you be prepared to back the crowdfunding campaign? If yes, what amount would you be prepared to invest?

Please use the form below to share your thoughts. Thank you! I appreciate it.

Enjoyed this post? There is more! Join us at the next Drupal Media sprint at the Mountain camp in Davos! Playing with the Sculpin static site generator Results of the Drupal 8 media sprint
Categories: Drupal

Advertising Products

New Drupal Modules - 6 February 2017 - 1:04am

Add entity type for advertising products. Currently supported product providers generic, amazon and tracdelight.

Currently only a pre-alpha release! Previous we need some re-factoring and code cleanup.

Categories: Drupal

Troy’s Crock Pot: Floating Down the Lazy River

Gnome Stew - 6 February 2017 - 1:00am

Ordinarily, you’d find me in the same camp as those who advocate that a well-run gaming session is one that is highly structured. And that a good GM is someone who is purposeful, putting to good use the time allotted to them.

Keep up the energy. Maintain pacing. Provide direct interactions.

For certain, there’s been an industry trend that emphasizes structured play, such as for conventions, organized leagues and scheduled streaming sessions, mostly to meet the demands of our time-crunched lives.

So, what I’m about to suggest in this column runs counter to that perspective.

No, I’m not abandoning my core beliefs. Goodness sakes, no. A well-prepared GM makes a good GM. I’m the guy who tracks 15-minute spotlight increments using Trivia Pursuit tokens. I think reaching certain markers in an adventure or storytelling session within the constraint of a set period is usually a good thing.

But I also think there’s nothing wrong with GMs deciding to — and forgive me for egregiously mixing metaphors — to hop off the tread-wheel and take a ride on the lazy river.

You know the lazy river, right? Water parks have them. That gentle stream that encircles the park where folks of a certain age (checks mirror for own gray hairs) drift past on inner-tubes while the kids hyped up on Skittles and Cap’n Crunch romp, jump, splash, dive and slide at high speed on all the other attractions.

It does the soul good to run a session like a ride on the lazy river. Remove the urgency to get somewhere and just follow the current of player interaction and see where it leads. Maybe the adventuring will be a tad meandering, and initially, one’s patience might be tested. But a gaming session that doesn’t feel like it’s on the clock actually has some advantages.

Here they are:

Time for roleplayers to flesh out their character’s personality. The ride across the countryside, the long meandering passages between dungeon complexes, the ocean voyage are all opportunities for players to find their character’s “voice” outside of a stressful combat situation. You want good roleplaying? Let the players find their role.

Let combats play out. Not every player comes up with battlefield strategy with the aplomb of General U.S. Grant in six-second increments. This approach is especially beneficial when trying out a new rules system or, in a level-based game, a higher tier of play for the first time. Sometimes we need space to change our mind, have second thoughts, master the new or complicated rules. Providing the players with time to think about tactics at this stage might actually help speed up combats by providing them with experiences they can use in the future.

Get immersed in the campaign setting. Luxuriate in its flavor. Players and GMs could both use a double dose of this from time to time. Learn the idiosyncrasies of the place and time you are adventuring in. Research, investigate, observe and question the imaginary place. You know, “live in” the world before setting off on the next adventure. New campaign settings are released all the time; how often are they actually explored? (I think roleplaying in published campaign settings have a problem analogous to that of spacefarers in the sci-fi classic “The Mote in God’s Eye” in that they do faster-than-light hopscotch jumps through the universe, but never know what lies between those places.)

Get to know the people around the table. Socialize. Take advantages of pauses in the narrative to share life’s highs and lows, mirth and madness. We all have hard edges that grate against people from time to time, even friends. When gamers take time to know each other, it can help soften those edges and facilitate understanding. Maybe, if you’ve removed the pressure-cooker from play, then that one player’s annoying idiosyncrasies won’t seem quite so aggravating.

If you think your game could benefit from having these things happen, consider taking your playing group for a ride on the lazy river. It could be a rewarding session, even if the storyline advances no faster than the water lapping against your inner tube.

Categories: Game Theory & Design

Fuzzy Thinking: Roll a d1!

RPGNet - 6 February 2017 - 12:00am
Fuzzy dice.
Categories: Game Theory & Design

File Download Tracker

New Drupal Modules - 5 February 2017 - 9:53pm

File download tracker.

Categories: Drupal

Age field formatter

New Drupal Modules - 5 February 2017 - 6:11pm

This module is a date field formatter that takes the value from a date field and display the age, based on the date entered.

The formatted value can display the original date with the calculated age in parentheses, or only the age value.

Similar module

Core date module, which offers a Time ago formatter.

Categories: Drupal

Commerce Criteo

New Drupal Modules - 5 February 2017 - 1:37pm

Implements all event "tags" for the Criteo re-marketing service, and uses Token module to set how to extract required data (product ID and price) from nodes.

Categories: Drupal Drupal Developer's blog: Ctools: custom access plugin

Planet Drupal - 5 February 2017 - 9:12am
Last time we've learned how to create custom ctools content type plugin. In that post we've already created a module example_module where we defined the plugin. This time we will learn how to create custom ctools access plugin. This type of ctools plugins can be used as a selection rule for a panel variant or as a visibility rule for a panel pane. Please, read previous post before continue reading this. There is described how to create a module and integrate it with ctools.
Read more »
Categories: Drupal

Video Game Deep Cuts: Fuudo&#039;s United Nations - by Simon Carless Blogs - 5 February 2017 - 7:49am
In the latest Video Game Deep Cuts 'best links of the week' update, we've got everything from the United Nations to pro gamer Fuudo in the mix.
Categories: Game Theory & Design

Commerce Apple Pay (Stripe)

New Drupal Modules - 5 February 2017 - 5:45am

Provides Apple Pay payment method for Drupal Commerce (through Stripe).

Module is currently under active development. Please follow this issue to get updates on development progress.

Categories: Drupal

Web components

New Drupal Modules - 4 February 2017 - 10:20pm

Web components are the future. Not layout systems, not template engines, not endless tpl files. is an emerging web industry standard to replace all of that. This module allows your front end people to develop exclusively in things like polymer and to have no knowledge of Drupal to do work for Drupal.

It has support for multiple component engines but we initially support Polymer which is incredibly powerful for creating simple reusable, well documented templates.

Categories: Drupal

Review Roundup

Tabletop Gaming News - 4 February 2017 - 11:00am
Hello Saturday. The Chuck Mangione from yesterday has switched over to Danger Doom, because that’s the sort of mood I’m in. Other than that… not much happening on this side of the screen. A chill Saturday on a chilly Saturday here in Atlanta (seriously, we’ve actually got winter for a couple days before it’s supposed […]
Categories: Game Theory & Design Drupal Developer's blog: Ctools: custom content type plugin

Planet Drupal - 4 February 2017 - 5:37am
Ctools content types are an alternative to standard Drupal blocks. They are more comfortable and powerfull than blocks. Ctools content type plugins also known as panel panes. In this post you will learn how to create a configurable ctools content pane plugin.
Read more »
Categories: Drupal

Poll correct answer

New Drupal Modules - 3 February 2017 - 5:29pm

This module allows you to specify the correct answer for a poll question. When the correct answer has been selected, poll takers will see the correct answer displayed above the poll results.

This module is an add-on to the Poll module provided with Drupal core.

Categories: Drupal

Online game firm Perfect World has executed a round of layoffs

Social/Online Games - Gamasutra - 3 February 2017 - 3:28pm

Online game company Perfect World Entertainment has told Gamasutra that it laid off a number of employees this week, but claims the cuts will not affect any of its current game projects. ...

Categories: Game Theory & Design

Freelock : Ways to measure your website’s effectiveness

Planet Drupal - 3 February 2017 - 3:11pm

We've worked with many clients over the years, who all have very specific website development needs. While some clients may share common goals, each may approach those business goals in different ways. But, time and time again, we usually start by asking a client in what ways are they measuring their website's effectiveness. In this 4 part series, I'll discuss identifying purpose and overcoming obstacles, complaints of current site capabilities and establishing budget, metrics to success and selecting a vendor, then finally risk tolerance and disaster recovery planning.

Categories: Drupal

One Drunk Night Card Game Up On Kickstarter

Tabletop Gaming News - 3 February 2017 - 3:00pm
You know, I’ve never been drunk. Honestly. I’m a teetotaler, so there’s not much opportunity for it. However, hanging around gamers, who I have found tend to enjoy imbibing alcohol, I’ve certainly heard plenty of stories that start with, “Ok, and I was so drunk when…” Well, now the idea of telling about drunken antics […]
Categories: Game Theory & Design


Subscribe to As If Productions aggregator