How to Draw a T-Rex Dinosaur

Final product image

What You’ll Be Creating

We all loved dinosaurs as children, and T-Rex is the favorite of many. This huge, ferocious beast surely captures our imagination! 

In this tutorial I will show you how to draw one, but also more than that—I will teach you how to draw an animal from scratch, using 3D blocks to build a final 3D form of the creature.

1. How to Sketch a Dinosaur Silhouette

Step 1

Draw a shallow arc—this will be the back of our dinosaur.

sketch dinosaur back

Step 2

Add the curved neck and the tail (the tail should be longer than the rest of the body).

sketch dinosaur neck and tail

Step 3

Add a boxy body under the back. It should have a longer front (chest) and a shorter back (hips).

sketch dinosaur body

Step 4

Sketch the legs. They’re just like our legs, except T-Rex walks on its toes.

sketch dinosaur legs

Step 5

Sketch the width of the feet. This will help you see their position better.

sketch dinosaur feet

Step 6

Sketch the head. It doesn’t need to be detailed—just an egg shape at the end of the neck.

sketch dinosaur head

Step 7

Sketch the places for the eyes and nostrils to understand the perspective you’re creating.

sketch dinosaur eyes

Step 8

Now add the shoulders and arms; nothing fancy here.

sketch dinosaur arms

Step 9

Complete the silhouette with the “lower neck” and “lower tail”.

sketch dinosaur silhouette

2. How to Draw the T-Rex’s Head

Step 1

We have the skeleton of our drawing—we can see exactly where we’re going. Now we can add the detailed blocks of the body.

Start by sketching a cube or a cuboid inside the head of our dino. Its perspective must match the perspective you’ve sketched before—it can’t be random! In other words, the cube should be facing the same way as the dinosaur.

how to draw dino head in perspective

If you want to learn how to do it, don’t copy my lines, but rather try to understand why I decided to draw them this way.

Step 2

Extend the bottom of the cube to create the length of the muzzle. Cross it with its width. The muzzle of the T-Rex is narrower than the skull.

how to draw dino upper jaw

Step 3

We’re going to create two ellipsoidal domes for the muzzle, but they’re seen in perspective, so we need to do it vary carefully. An ellipse in perspective has long, flat arcs in front of the obtuse angles…

how to draw ellipse in perspective

… and short, convex arcs in front of the acute angles. Remember this rule!

how to draw ellipsoid in perspective

Step 4

Use the same rule to create the other ellipses building this “dome”.

dome in perspective
ellipsoid in 3d
how to draw dino upper jaw

Step 5

Connect the dome with the rest of the skull.

how to draw trex skull

Step 6

Create a smaller version of the same dome in the lower jaw. Relax—you already know how to do it!

how to draw lower jaw

Step 7

Finish the lower jaw by creating its wider part first…

how to draw dino jaws

… then completing the lines.

how to draw trex jaws

Step 8

Draw the teeth all around the jaws. They should be slightly uneven and not completely pointed.

how to draw trex teeth

Step 9

Finish the head by adding the eye socket with the tiny eye inside, and the jaw muscles.

how to draw trex eye

3. How to Draw T-Rex Feet and Claws

Step 1

Feet and hands are made of many small elements allowing for motion. Let’s work on them one by one.

Draw cylinders in the place of the joints: in the ankle and right before the toes.

how to draw trex feet joints

Step 2

Connect both cylinders with blocks.

how to draw trex feet

Step 3

Draw small domes at the tips of the toes. You don’t need to draw them all at once, if they cover each other. Make the middle dome the biggest.

how to draw trex toes

Step 4

Draw the openings for the claws in the front of each dome.

how to draw dinosaur claws

Step 5

Draw big, slightly curved claws.

how to draw trex claws

Step 6

To finish the toes, connect the domes with the cylinders with a path of “plates”.

how to draw dinosaur feet

Step 7

Then add the lower part.

how to draw dragon feet

Step 8

Finish the feet by adding the toes in the back, a “foot-thumb”, and a foot pad below the toe joints.

how to draw t rex legs

Step 9

Let’s draw the arms now. They’re short, but heavily muscled. Start with two circles for these muscles.

how to draw trex arms

Step 10

Draw the little forearms.

how to draw trex forearms

Step 11

Add some depth to the arm by drawing directing lines on it.

how to draw dinosaur arms

Step 12

Draw the tips of both fingers on each hand.

how to draw dinosaur fingers

Step 13

Draw the top…

how to draw dinosaur hands

… and bottom of each finger.

how to draw dinosaur foot pads

Step 14

Finally, add the little claws.

how to draw t rex hand claws

4. How to Draw the Dinosaur’s Body

Step 1

To draw the shoulders, imagine a horse collar on them. First draw its opening…

how to draw dinosaur shoulders

… then its side surface…

how to draw trex shoulders

… and finally, its lower part that will be the chest.

how to draw trex chest

Step 2

Draw big muscle masses for both the thigh and the calf.

how to draw trex legs

Step 3

Let’s add perspective to the hind legs now. Use directing lines to mark the front and side of the calves.

how to draw trex limbs

Step 4

Do the same with the thigh, adding the knee between both parts.

how to draw trex thigh

Step 5

Time to add volume to the rest of the body. The T-Rex’s neck should be visibly S-curved. You can achieve that by drawing curved lines between the head and the shoulders.

how to draw trex neck

Step 6

But that’s not all! Cross them with more lines to show the curving side of the neck.

how to draw trex neck in 3d

Step 7

Use the same trick to define the volume of the rest of the body.

how to draw trex body

Notice the depression between the chest and hips.
how to draw dinosaur hips

Don’t forget about these funny dinosaur hips!
how to draw dinosaur body

5. How to Draw the Dinosaur’s Skin and Details

Step 1

The base for the drawing is finished, so we can draw the final lines now. In digital art you can create a new layer now. In traditional art, put a new sheet of paper over the drawing or draw the final lines with a darker tool.

Draw the tiny eye and the nostrils.

how to draw trex face

Step 2

Outline the shape of the head. If you want a realistic T-Rex, cover the teeth more (or skip to the end of this tutorial to learn more about T-Rex realism).

how to draw trex head

Step 3

Outline the teeth and add some details to the skull. The depressions in the skull are not necessary if you want to be more realistic.

how to draw t rex skull details

Step 4

Envelop the whole body into one piece of skin. Draw wrinkles between the separate parts of the body.

how to draw t rex skin

Step 5

The hands and feet should be enveloped in one piece of skin as well. There will be more wrinkles, because there are more elements here.

how to draw dragon claws

Step 6

You can add more wrinkles all over the skin to accentuate the directing lines and stress the perspective of the body.

how to draw dinosaur skin

Step 7

Finally, you can shade the body to show the volume even better.

how to shade dinosaur

Step 8

If you want to create a more scientifically accurate T-Rex, you need to make some changes:

  • The teeth should be mostly covered (by gums and lips), because T-Rex is not aquatic like a crocodile and its teeth would dry out being so bare.
  • The body should be a little rounder—the bones don’t tell us anything about the fat layer, but it doesn’t mean we should accentuate the bones so much.
  • There’s evidence that other dinosaurs of T-Rex family had feathers, so it’s likely that T-Rex had them as well—at least on a part of its body. If so, they weren’t used for flight, but for warmth.
how to draw realistic trex

It may look like a bird, but remember that birds are dinosaurs as well!

Grrreat Job!

Do you want to learn more about this technique of drawing animals? Check these out:

how to draw t rex step by step from scratch
View Tutorial: How to Draw a T-Rex Dinosaur

Using Namespaces and Autoloading in WordPress Plugins, Part 4

If this is the first tutorial you’re reading in this series, then I highly recommend catching up with what we’ve covered thus far.

Essentially, you’re coming in at the end of the show. At this point, we’ve laid the foundation for our plugin, written the plugin, and defined and explored namespaces and autoloaders. All that’s left is to apply what we’ve learned.

So in this tutorial, we’re going to put all of the pieces together. Specifically, we’re going to revisit the source code of our plugin, namespace all relevant classes, and write an autoloader so that we can remove all of our include statements.

I’ll discuss everything in detail as we work through the code. Again, if this is the first tutorial you’re reading in this series, catch up with what we’ve covered so far and then return to this tutorial.

Before We Write Any Code

By this point, you should be familiar with how we’ve set up our development environment. As a refresher, here’s a quick rundown of the software we’re using:

  • at least PHP 5.6.20
  • the Apache web server
  • a MySQL database server
  • WordPress 4.6.1
  • a working knowledge of the WordPress Plugin API

You’re also going to need a copy of the source code of the plugin with which we’re working. You can grab a copy of it right here. Assuming it’s installed, activated, and you’ve got your IDE running, let’s get started.

Namespacing the Code

Recall from the previous tutorial, I’m a fan of making sure that our namespaces follow the organization of the files on disk. If you look at the directory structure of our plugin or if you’ve been following along with the series thus far, you should see something like this:

The directory structure of our plugin

Note that if you’ve set up your plugin differently, that’s fine. Your namespaces will likely be different, but that shouldn’t affect anything that’s covered in this series.

Using the directory structure as a guideline, let’s go through all of the PHP files that make up our plugin and define their namespaces. Doing this is easy: It’s simply a matter of using the namespace keyword and placing a qualified name at the top of each file.

I’ll list each one below.

tutsplus-namespace-demo.php

<?php
/**
 * The plugin bootstrap file
 *
 * This file is read by WordPress to generate the plugin information in the
 * plugin admin area. This file also includes all of the dependencies used by
 * the plugin, registers the activation and deactivation functions, and defines
 * a function that starts the plugin.
 *
 * @link              http://.tutsplus.com/tutorials/using-namespaces-and-autoloading-in-wordpress-plugins-part-1
 * @since             0.1.0
 * @package           tutsplus_namespace_demo
 *
 * @wordpress-plugin
 * Plugin Name:       Tuts+ Namespace Demo
 * Plugin URI:        http://.tutsplus.com/tutorials/using-namespaces-and-autoloading-in-wordpress-plugins-part-1
 * Description:       Learn how to use Namespaces and Autoloading in WordPress.
 * Version:           0.2.0
 * Author:            Tom McFarlin
 * Author URI:        https://tommcfarlin.com/
 * License:           GPL-2.0+
 * License URI:       http://www.gnu.org/licenses/gpl-2.0.txt
 */

namespace Tutsplus_Namespace_Demo;

// If this file is accessed directory, then abort.
if ( ! defined( 'WPINC' ) ) {
    die;
}

class-meta-box.php

<?php
/**
 * Represents a meta box to be displayed within the 'Add New Post' page.
 */

namespace Tutsplus_Namespace_Demo\Admin;

class-meta-box-display.php

<?php
/**
 * Defines the functionality required to render the content within the Meta Box
 * to which this display belongs.
 */

namespace Tutsplus_Namespace_Demo\Admin;

interface-assets.php

<?php
namespace Tutsplus_Namespace_Demo\Admin\Util;

class-css-loader.php

<?php
/**
 * Provides a consistent way to enqueue all administrative-related stylesheets.
 */

namespace Tutsplus_Namespace_Demo\Admin\Util;

class-question-reader.php

<?php
/**
 * Reads the contents of a specified file and returns a random line from the
 * file.
 */

namespace Tutsplus_Namespace_Demo\Admin\Util;

There are a few things to notice about the conventions I’ve used above:

  • The root namespace is Tutsplus_Namespace_Demo, which corresponds to the directory name of the plugin.
  • The rest of the namespaces such as Tutsplus_Namespace_Demo\Admin and Tutsplus_Namespace_Demo\Admin\Util also correspond to their respective directories; however, the directory names are cased (versus being in lowercase).

Finally, if you’ve tried to refresh the page or you’ve tried to navigate around WordPress since introducing the namespace statements, then you’re likely seeing an error in your console that looks something like this:

PHP Errors when loading namespaced code

And it includes the following message:

PHP Warning:  call_user_func_array() expects parameter 1 to be a valid callback, function ‘tutsplus_namespace_demo’ not found or invalid function name in /Users/tommcfarlin/Dropbox/Projects/tutsplus/wp-includes/plugin.php on line 524

Or perhaps it shows:

PHP Fatal error:  Class ‘Meta_Box’ not found in /Users/tommcfarlin/Dropbox/Projects/tutsplus/wp-content/plugins/tutsplus-namespace-demo/tutsplus-namespace-demo.php on line 48

Or you may see any number of other similar error messages. That’s okay. It’s normal.

But it raises the question: What’s up with our plugin? Luckily, nothing. This is expected behavior.

The first message that you see may be a result of another plugin that you have installed. I was unable to reproduce it on its own; however, when I deactivate a few of the other plugins I have running, the plugin generated the second message (which is the message I wanted to demonstrate).

When you namespace code, PHP expects to locate a class within a given namespace. Conceptually you can think of your classes now belonging to their own package (or subpackage) or however you define it. And in order for a function to access a class within a package, it needs to be made aware of the packages that exist.

This is where additional namespace functionality and autoloading comes into play. So before we go about trying to access our code via their namespaces, let’s work on an autoloader.

All About Autoloading

Writing an autoloader will require the following:

  1. understanding a PHP function called spl_autoload_register
  2. writing a function that will automatically load our namespaced files
  3. including our custom autoloading function

Don’t let the name spl_autoload_register intimidate you. It simply means that this is a function that’s part of the “Standard PHP Library” and it’s how we “register” an “autoload” function. It’s a mouthful to say and a lot of characters to write, but it’s just a function that we’re going to use to tell PHP how to parse namespaces and class names and where it can find our files.

This function is what allows us to write our own custom code for autoloading files and then hooking said function into PHP. That is, we’re going to be telling PHP where to find our files and how to parse namespaces, file names, and so on so that it will include the files.

With all of that said, we’re ready to actually write an autoloader.

Writing an Autoloader

When writing an autoloader, the thing to keep in mind is how our files are organized. That is, we want to know how to map our namespaces to our directories. 

In the example we’re using, it’s simple: The namespaces are cased versions of the directory structure. This is not always true for other projects; however, it’s yet another reason why I like to logically organize my files based on their physical location.

When PHP attempts to load a class, our autoloader is going to need to do the following:

  1. Split the namespace up based on the slashes.
  2. Split the package and the subpackages up based on underscores and replace them with hyphens (if necessary).
  3. Know how to map class names, interfaces, and so on to file names.
  4. Create a string representation of the filename based on the above information.
  5. Include the file.

With all of those points made, we’ve got our work cut out for us. In the plugin directory, create a subdirectory called inc, and in the inc directory create a file called autoload.php.

Within that file, let’s go ahead and stub out the function that we’re going to use to autoload our files. It should look something like this:

<?php
/**
 * Dynamically loads the class attempting to be instantiated elsewhere in the
 * plugin.
 *
 * @package Tutsplus_Namespace_Demo\Inc
 */

spl_autoload_register( 'tutsplus_namespace_demo_autoload' );

/**
 * Dynamically loads the class attempting to be instantiated elsewhere in the
 * plugin by looking at the $class_name parameter being passed as an argument.
 *
 * The argument should be in the form: TutsPlus_Namespace_Demo\Namespace. The
 * function will then break the fully-qualified class name into its pieces and
 * will then build a file to the path based on the namespace.
 *
 * The namespaces in this plugin map to the paths in the directory structure.
 *
 * @param string $class_name The fully-qualified name of the class to load.
 */
function tutsplus_namespace_demo_autoload( $class_name ) {

    // If the specified $class_name does not include our namespace, duck out.
    if ( false === strpos( $class_name, 'Tutsplus_Namespace_Demo' ) ) {
        return;
    }

    // More to come...
}

Obviously, this isn’t doing anything yet.

A Side Note on Writing an Autoloader

Note that I’m going to be writing the code and code comments to thoroughly explain what we’re doing. If you’re just venturing into this on your own for the first time, writing an autoloader along with using namespaces and working with files might be a bit frustrating. This is where a debugger and using log files can come in handy. 

This is outside the scope of this tutorial, but know that writing an autoloader is not something that you may get right the first time you’re doing it.

Completing the Autoloader

Let’s start adding some functionality given the steps listed at the beginning of this section.

First, we need to set up a loop that’s going to iterate backwards through the parts of the filename that are passed into the autoloading function. We do this because it makes it easier to build a path to the file to autoload.

<?php
function tutsplus_namespace_demo_autoload( $class_name ) {

    // If the specified $class_name does not include our namespace, duck out.
    if ( false === strpos( $class_name, 'Tutsplus_Namespace_Demo' ) ) {
        return;
    }

    // Split the class name into an array to read the namespace and class.
    $file_parts = explode( '\\', $class_name );

    // Do a reverse loop through $file_parts to build the path to the file.
    $namespace = '';
    for ( $i = count( $file_parts ) - 1; $i > 0; $i-- ) {
        // More to come...
    }
}

After this, we need to look at the $file_parts and replace all occurrences of the underscore with a hyphen because all of our class names and interface use underscores whereas our filenames use hyphens.

The following two lines are the first two lines inside of the loop that we stubbed out above:

<?php

// Read the current component of the file part.
$current = strtolower( $file_parts[ $i ] );
$current = str_ireplace( '_', '-', $current );

Next, we’re going to need a conditional that does a few things.

  1. It needs to check to see which entry of the path of the filename that we’re reading.
  2. If we’re on the first entry, then we’re at the file name; otherwise, we are at its namespace.
  3. Next, if we’re reading the first entry, we need to determine if we’re trying to autoload an interface or we’re loading a class.
  4. If it’s the former, then we need to adjust the name of the interface so we load it properly based on its filename; otherwise, we’ll load the class based on the value in the $current variable.

It reads like a lot, but it shouldn’t be terribly complicated to read. See the commented code below:

<?php

// If we're at the first entry, then we're at the filename.
if ( count( $file_parts ) - 1 === $i ) {

        /* If 'interface' is contained in the parts of the file name, then
	 * define the $file_name differently so that it's properly loaded.
	 * Otherwise, just set the $file_name equal to that of the class
	 * filename structure.
	 */
	if ( strpos( strtolower( $file_parts[ count( $file_parts ) - 1 ] ), 'interface' ) ) {

		// Grab the name of the interface from its qualified name.
		$interface_name = explode( '_', $file_parts[ count( $file_parts ) - 1 ] );
		$interface_name = $interface_name[0];

		$file_name = "interface-$interface_name.php";

	} else {
		$file_name = "class-$current.php";
	}
} else {
	$namespace = '/' . $current . $namespace;
}

With that done, it’s time to build a fully-qualified path to the file. Luckily, this is little more than basic string concatenation:

<?php

// Now build a path to the file using mapping to the file location.
$filepath  = trailingslashit( dirname( dirname( __FILE__ ) ) . $namespace );
$filepath .= $file_name;

Lastly, we need to make sure the file exists. If not, we’ll display a standard WordPress error message:

<?php

// If the file exists in the specified path, then include it.
if ( file_exists( $filepath ) ) {
    include_once( $filepath );
} else {
    wp_die(
        esc_html( "The file attempting to be loaded at $filepath does not exist." )
    );
}

And at this point, we have a full autoloader (which can be retrieved by downloading the files from the link in the sidebar of this post as the source code would be a bit long to post here in the tutorial).

Finally, it’s important to note that this particular function could (or should) be rewritten as a class. Furthermore, the class should consist of several smaller functions of which are testable, have a single responsibility, and read more clearly than what’s above. Perhaps in a bonus tutorial, I’ll walk through the process of what that would look like.

But We’re Still Including Files

If you look near the top of the main plugin file (or the bootstrap file that we’ve often called it), you’ll notice several include statements that look like this:

<?php

// Include the files for rendering the display.
include_once( 'admin/class-meta-box.php' );
include_once( 'admin/class-meta-box-display.php' );
include_once( 'admin/util/class-question-reader.php' );

// Include the files for loading the assets
include_once( 'admin/util/interface-assets.php' );
include_once( 'admin/util/class-css-loader.php' );

Given the work that we’ve done up to this point, we can finally remove these statements and replace them with only one:

<?php

// Include the autoloader so we can dynamically include the rest of the classes.
require_once( trailingslashit( dirname( __FILE__ ) ) . 'inc/autoloader.php' );

To be clear, we’re replacing it with our autoloader. At this point, we should be done with our plugin.

Putting It All Together

Now that we’ve namespaced our code to provide a logical organization of related classes, and written an autoloader to automatically include files based on each class’s namespace and file location, we should be able to start our plugin and have it run exactly as it did during the first successful iteration.

The last thing we need to do is make sure that we update the bootstrap file so that we instruct PHP to use the namespaces for the Meta_Box, Meta_Box_Display, the Question_Reader, and the CSS_Loader.

<?php

use Tutsplus_Namespace_Demo\Admin;
use Tutsplus_Namespace_Demo\Admin\Util;

// If this file is accessed directory, then abort.
if ( ! defined( 'WPINC' ) ) {
    die;
}

// Include the autoloader so we can dynamically include the rest of the classes.
require_once( trailingslashit( dirname( __FILE__ ) ) . 'inc/autoloader.php' );

add_action( 'plugins_loaded', 'tutsplus_namespace_demo' );
/**
 * Starts the plugin by initializing the meta box, its display, and then
 * sets the plugin in motion.
 */
function tutsplus_namespace_demo() {

    $meta_box = new Admin\Meta_Box(
        new Admin\Meta_Box_Display(
            new Util\Question_Reader()
        )
    );

    $css_loader = new Util\CSS_Loader();
    $css_loader->init();

    $meta_box->init();
}

Notice in the code above we’re using PHP’s use keyword, and we’re prefixing our class names with their immediate subpackages. You can read more about use in the manual, but the short of it is:

The use keyword must be declared in the outermost scope of a file (the global scope) or inside namespace declarations. This is because the importing is done at compile time and not runtime, so it cannot be block scoped. 

With that said and assuming all works correctly, you should be able to navigate to the Add New Post page (or Edit Post) page, view our meta box, and see a question prompt along the top of the sidebar:

The meta box prompting users for inspiration

If so, then congratulations. You’ve successfully set up your plugin to your namespaces and autoloading. If not, double-check the code against what we’ve shared here, review your error logs, and make sure nothing is showing up out of the ordinary in the WordPress administration screen.

If you do see something, odds are it has to do with something minor. Review the code we’ve covered, compare it to what’s attached here to this post (in the sidebar along with the large blue button), and see if you can narrow down the issue.

Conclusion

At this point, we’ve reached the end of our series. Throughout the last four tutorials, we’ve covered a lot of ground:

  • We’ve built a plugin that prompts users with questions to help kickstart their blogging.
  • We’ve used PHP functions for reading files from the filesystem and rendering it in the display.
  • We’ve defined namespaces and autoloading, and taken a look at how they can be applied.
  • We’ve organized our code and written our own autoloader, making the code more readable, organized, and less cluttered.

Ultimately, a lot of the material covered throughout this series can be used in existing and future projects on which you may be working. 

Remember that you can also find other WordPress-related products in our marketplace. And if you want to learn more about developing solutions for WordPress, you can find all of my tutorials and series on my profile page. Don’t hesitate to follow me on my blog or on Twitter as I discuss software development in the context of WordPress almost daily.

And remember, the link is for downloading the final source code is in the sidebar under a button titled Download Attachment. Of course, don’t hesitate to ask any questions in the comments!

Resources

View Tutorial: Using Namespaces and Autoloading in WordPress Plugins, Part 4

Building Your Startup: Preparing for Text Messaging

Final product image

What You’ll Be Creating

This tutorial is part of the Building Your Startup With PHP series on Envato Tuts+. In this series, I’m guiding you through launching a startup from concept to reality using my Meeting Planner app as a real-life example. Every step along the way, I’ll release the Meeting Planner code as open-source examples you can learn from. I’ll also address startup-related business issues as they arise.

Preparing for Text Messaging

When you’re on the go and scheduled meeting times are approaching, receiving helpful text messages is often more useful than email reminders. I’ve always known that text (or SMS) messaging would play a useful part in Meeting Planner.

In today’s episode, I’m going to walk you through the first half of my SMS configuration for the Meeting Planner application. Basically, I’ll cover choosing an SMS provider, setting up the account, building the initial application infrastructure, and trial texting.

In the next episode, I’ll build specific texting scenarios into the Meeting Planner application and walk you through those decisions and the coding that followed.

If you haven’t yet, please try out Meeting Planner right now by scheduling your first meeting. Feel free to post feedback about your experience in the comments below. 

I do participate in the comment threads, but you can also reach me @reifman on Twitter. I’m always open to new feature ideas and topic suggestions for future tutorials.

As a reminder, all the code for Meeting Planner is written in the Yii2 Framework for PHP. If you’d like to learn more about Yii2, check out my parallel series Programming With Yii2. The more I build out Meeting Planner, the more impressed I am with Yii2 and their team of volunteers.

Choosing an SMS Provider

The easiest way to send text messages from your application is to subscribe to a service. Just as I use Mailgun for Meeting Planner’s inbound and outbound email, I’ll need an SMS provider to deliver text messages.

The two most prominent services I looked at were Twilio and Plivo. Both seemed like competent providers, but Twilio had broader services, richer documentation, and top-level user experience. 

Here’s a screenshot from Twilio’s SMS product page:

Building Startups Text and SMS - Twilio Home Page for SMS Features

Twilio offers such an array of services that you do have to dive in a bit to find SMS:

Building Startups Text and SMS - Twilio Product Offering Menu

Plivo also seemed like a good choice, but its website, documentation and API didn’t seem to be quite as sophisticated as Twilio:

Building Startups Text and SMS - Plivo Home Page

However, Plivo is a lot cheaper than Twilio; specifically, it offers free inbound SMS:

Building Startups Text and SMS - Pricing Comparison Twilio vs Plivo

I decided to go with Twilio for my initial SMS implementation, but to modularize the features so I could easily switch them to a different provider.

I do have some concerns about the costs of texting in Meeting Planner as the audience scales. Will I offer SMS for free to all users even before there is a revenue stream or investors?

At the early alpha stage, this wasn’t a top concern. Again, I’m still focused on delivering the best MVP I can for the beta release.

Getting Started With Twilio

Signing Up

Registering with Twilio is easy:

Building Startups Text and SMS - Twilio Sign Up

As a sophisticated communication services provider, they implement SMS verification in their registration process:

Building Startups Text and SMS - Twilio Verification

The SMS Dashboard

Once verified, you land on a friendly, well-designed dashboard:

Building Startups Text and SMS - Twilio SMS Dashboard

Gathering Our Credentials

First, I accessed the account ID and token from the API Credentials page:

Building Startups Text and SMS - Twilio SMS Dashboard

I made note of these for later integration with Meeting Planner.

Obtaining a Phone Number

Twilio provides you a phone number from which you can send SMS from your application:

Building Startups Text and SMS - Twilio Get Your Phone Number

I chose a number with a Seattle area code, where Meeting Planner is based:

Building Startups Text and SMS - Twilio Your New Phone Number is

Then, using Twilio, I sent my first test message:

Building Startups Text and SMS - Twilio Test Send a Message

The message arrived very quickly on my phone.

Thinking About Incoming Messages

Thinking beyond the MVP, incoming message capability would be great for Meeting Planner. For example, you could text that you’re running late or need a convenient link to directions for your phone’s navigation app. Currently, you have to click through to the web to the meeting invitation to do this.

Twilio offers a rich set of services for responding to inbound texts, including a texting markup language called TwiML.

Building Startups Text and SMS - Twilio Incoming Messages

For the moment, I’m not going to worry too much about inbound messages. However, anytime people text your Twilio number, you are charged; in other words, it’s ripe for abuse.

Let’s look at a couple of easy ways to manage costs.

Controlling Costs

For alpha and beta testing, I am limiting text support to North American phone numbers. This will keep costs a bit lower. Twilio offers a built-in way to filter by geography:

Building Startups Text and SMS - Controlling Geo Permissions for Managing Costs

Twilio also provides Messaging Services which you can configure to behave in specific ways tailored for your application, including blocking all SMS:

Building Startups Text and SMS

As you can see, they also see inbound text spam and abuse as a weakness in the general SMS platform (not theirs) which they are thoughtful about.

Integrating Twilio Into Meeting Planner

Next, I wanted to get the basic SMS functionality operating within Meeting Planner.

Finding a Yii Extension for Twilio

It turns out there are several available extensions for Twilio with the Yii Framework. I decided to install Filip Ajdačić‘s YII2 wrapper for Twilio PHP SDK (GitHub) because his name was the most unusual (just kidding, his extension seemed to be regularly maintained).

I added the extension to composer.json. As it’s technically in development mode, this worked better than directly requiring the extension:

"filipajdacic/yii2-twilio": "dev-master"

Then, I updated the environment:

$ composer update
Loading composer repositories with package information
Updating dependencies (including require-dev)
  - Removing ezyang/htmlpurifier (v4.7.0)
  - Installing ezyang/htmlpurifier (v4.8.0)
    Downloading: 100%

  - Installing twilio/sdk (4.10.0)
    Downloading: 100%

  - Installing filipajdacic/yii2-twilio (dev-master 7d547a0)
    Cloning 7d547a0a47c9864f2e8b5fb5f43748fbd24fc4b1

Writing lock file
Generating autoload files

I wasn’t too worried about its development status because it’s a relatively simple, straightforward extension that just activates the Twilio API.

Adding the Credentials

First, I added the keys from above to my initialization files:

twilio_sid = "ACxxxxXXxxxxxXXxxxXXxxxxxxxxxxxe1"
twilio_token = "d3xxxxXXxxxxxXXxxxXXxxxxxxxxxxx41"
twilio_number = "1206XXXYYYY"
# for next episode
#twilio_service_sid = "MxxxxXXxxxxxXXxxxXXxxxxxxxxxxxGf6"

Then, I added registration of the component in /frontend/config/main.php:

return [
    'id' => 'mp-frontend',
    'name' => 'Meeting Planner',
    'basePath' => dirname(__DIR__),
    'bootstrap' => ['log'],
    'controllerNamespace' => 'frontend\controllers',
    'components' => [
    ...
        'Yii2Twilio' => [
          'class' => 'filipajdacic\yiitwilio\YiiTwilio',
          'account_sid' => $config['twilio_sid'],
          'auth_key' => $config['twilio_token'],
        ],
        'log' => [
        ...

I also found it best to place a few of the variables in common\config\params-local.php for easier access across the application:

<?php
return [
  ...
  'sms_number' => '1206XXXYYYY',
  'twilio_service_id' => 'MGXXXXXYYYYZZZZ11134446',
  'twilio_test_number' => '1-206-NNN-QQQQ',
];

Building an SMS Model

Then I built an Sms.php model to use programmatically when texts were needed:

<?php
namespace common\models;
use Yii;
use yii\base\Model;
use frontend\models\UserContact;

class Sms
{
  private $sms;
  private $service_id;
  private $mp_number;
  private $test_number;

   function __construct() {

     $this->sms = Yii::$app->Yii2Twilio->initTwilio();
     $this->mp_number = Yii::$app->params['sms_number'];
     $this->service_id = Yii::$app->params['twilio_service_id'];
     $this->test_number = Yii::$app->params['twilio_test_number'];
  }

  public function transmit($user_id,$body='') {
    // to do - lookup usercontact to sms
    // see if they have a usercontact entry that accepts sms
    // transmit
    $to_number = $this->test_number;
    $to_number = $this->findUserNumber($user_id);
    if (!$to_number)
    {
      return false;
    }
    try {
        $message = $this->sms->account->messages->create(array(
            "From" => $this->mp_number,
            "To" => $to_number,   // Text this number
            'MessagingServiceSid' => $this->service_id,
            "Body" => $body,
        ));
    } catch (\Services_Twilio_RestException $e) {
            echo $e->getMessage();
    }
  }

Initially, findUserNumber() was a stub, and transmit() would only send to a test number in params-local.php, my personal cell phone.

Here’s some test code which I used to send my first message from Meeting Planner:

$user_id = 1;
$s = new \common\models\Sms();
$s->transmit($user_id,'First test from Meeting Planner codebase!');

Here are the results:

Building Startups Text and SMS - My First Twilio Text

Note: yeah, I know I should charge my phone—but it’s really the iPhone 6’s poor battery life that’s the problem.

So, that’s how you get signed up for Twilio and implement basic functionality.

Looking Ahead

In the next episode, we’ll explore actual integration of SMS with Meeting Planner. Here are some questions that will come up:

  • How will people provide their phone numbers for texting?
  • Which Meeting Planner features should use SMS for notifications and delivery?
  • How will people decide what they want to receive texts from Meeting Planner for?
  • Will Meeting Planner process inbound texts and respond to them?
  • How will I control SMS costs and prevent abuse during the MVP stage of the startup?
  • What would it take to switch to Plivo to lower costs?

As always, please stay tuned for more upcoming tutorials in the Building Your Startup With PHP series. As former Presidential candidate Donald Trump used to say, “We are going to win, win so much you’ll get tired of winning. You’ll say, ‘Please Jeff, stop winning’. And I’ll say, ‘No, sorry, get comfortable, there will be more ongoing winning.'”

Have you scheduled a meeting via Meeting Planner yet? No? Go! Do it. Do it now! And as always, let me know what you think below or in the comments. I appreciate it. I can’t keep winning without your help.

Related Links

View Tutorial: Building Your Startup: Preparing for Text Messaging

Envato Market in 60 Seconds: 3rd Party Apps

If you’re an author on Envato Market you can check your earnings status on the Earnings and Statement pages. But this isn’t the only way to do so; here are three apps you can use to do the same:

3× 3rd Party Apps

 

1. SalesDonkey

This is a Mac OS app which sits in your menu bar and displays your balance. It can notify you when you make a sale and supports multiple accounts.

2. nWallet

nWallet is an Android app which shows your balance, earnings, sales, and comments. It can also notify you of changes to the above mentioned things.

3. Vatomium

This is iOS only and is arguably the most complete of the three. It works on iPhone and iPad, does everything the previous two examples do, plus it also allows you to browse the Envato Marketplaces.

Useful Resources

View Tutorial: Envato Market in 60 Seconds: 3rd Party Apps

Introduction to Android Things

For over a year, Google worked with the Project Brillo operating system (which was built on the lower levels of Android) for Internet of Things (IoT) connected devices, even going so far as to have lessons and talks on it during the Ubiquity Dev Summit in January of 2016. 

In December of 2016, Google released an updated version of this operating system with another tier that allows Android application developers to use a stripped-down version of Android when creating connected devices. Although Android Things is currently in an early developer preview state, it looks promising as an IoT platform for quickly creating prototypes and supporting users at scale.

In this article, I’ll give you an introduction to how Android Things works and look briefly at some examples of how you could use it.

What Is Android Things?

Android Things is a lightweight version of Android that can be flashed onto different hardware prototyping boards, in order to easily create connected Internet of Things (IoT) devices. This makes embedded coding accessible to developers who might not have previous experience. With Android Things, Google has also provided a library that you can use to build apps that read from and write to different pins on the boards, allowing you to hook up different sensors and actuators to interact with the world.

So what makes Android Things different than other IoT prototyping solutions? Google has done a lot of the legwork to make specific hardware prototyping boards work, and will continue to provide updates to support built-in Bluetooth, wireless, software updates, and other functionality. 

This means that you, as a developer and creator, can start by prototyping your IoT device using a development board such as Raspberry Pi. Then, when you’re ready to take your product to market, you can design a stripped-down version of the hardware to save hardware production costs.

Current Device and Feature Support

At the time of this article, Android Things supports three prototyping boards: the Raspberry Pi 3 Model B, the Intel Edison with Arduino breakout board, and the NXP Pico i.MX6UL

While this may seem limited, a restricted supported hardware list allows Google to fully support these common prototyping boards and provides developers with a sturdy platform that has been tested and certified. 

Intel Edison with Arduino Breakout Prototyping Board

In addition to the previously mentioned three boards, Android Things will soon support the Intel Joule 570x and the NXP Argon i.MX6UL, giving you more hardware options for development.

Raspberry Pi 3 Model B Prototyping Board

Once you have a prototyping board, you will want to know what you can build with it. 

While we will go over the process of flashing a board and building connected projects in later tutorials, you can find a list of sample projects using drivers provided by Google for various sensors and actuators on their Android Things Driver Samples GitHub page

Some driver examples include servo motors, Pulse Width Modulation (PWM) speakers, buttons, GPS sensors, and HT16K33 supported alphanumeric segment display.  

7-segment and 14-segment HT16K33 backpack displays

In addition, you can read the source for these drivers on GitHub to create your own drivers for digital sensors or digital/PWM actuators, such as this quick example that I have written for the HC SR501 motion detector sensor.

HC SR501 Motion Detector Sensor

One thing to remember is that, at the time of this writing, Android Things is in the first iteration of its developer preview. This means that, because it’s an early release for testing and feedback, some features are currently unavailable or may be buggy as the platform is tested and built out. 

Currently Bluetooth communication is not enabled with the boards, and support for simple analog sensors is not included in the Android Things general-purpose input/output (GPIO) classes—though there is a technical reasoning for this, and you can still use SPI and I2C, as mentioned in this AOSP issue

As this platform is still new, there are not many drivers for sensors or other hardware, so developers using the platform will need to either create their own drivers or make do with what is currently available or open sourced by other developers in the Android Things community

Limitless Possibilities

One of the best things about building Internet of Things devices is that you aren’t limited to the hardware that ships with a phone, but are able to build out complex devices that fit the needs of your project. 

Although you may need to write the drivers for your own actuators and sensors, this process is still relatively straightforward given that the platform uses Java and an Android base, so you don’t need to dig into low-level languages to make your product work. This means if you decide to make an animated skeleton that uses motion detection and servo motors to move, you can!

 

In addition to being able to support new hardware, you get valuable portions of the Android ecosystem to work with. Using already supported features from Android, such as the Camera API, Play Services and Firebase, you can easily build a device that takes a picture through an Internet-connected device and attach it to your back-end service, such as Firebase Storage, or analyze the image through Google Play Service’s vision API.

Raspberry Pi with Camera Module

Conclusion

Given the ability to create your own devices and easily interact with Google Play Services and other back-end services (Firebase, machine learning services, etc.), Android Things promises to provide an easy-to-use platform for quickly creating new connected devices that can be brought to market or used for your own personal projects.

Stay tuned for some in-depth tutorials on getting set up and building projects with Android Things. To learn more about some of these related technologies, check out our other tutorials here on Envato Tuts+!

View Tutorial: Introduction to Android Things

How to Create a Lollipop Inspired Text Effect in Adobe Photoshop

Final product image

What You’ll Be Creating

This tutorial will show you how to use a couple of text and shape layers, along with a bunch of layer styles, textures, and filters, to create a realistic lollipop text effect. Let’s get started!

This text effect was inspired by the many Layer Styles available on GraphicRiver.

Tutorial Assets

The following assets were used during the production of this tutorial:

1. How to Create a Simple Background

Step 1

Create a new 1000 x 750 px document. Then, click the Create new fill or adjustment layer icon at the bottom of the Layers panel and choose Gradient.

Gradient Adjustment Layer

Step 2

Create the gradient fill using the colors #deeff0 to the left and #167e75 to the right. Change the Style to Radial, the Scale to 200, and check the Dither box. You can also click-drag the gradient in the document to move it around if you like.

Gradient Fill Settings

Step 3

Place the SpiritsighsTexture22 image on top of the Background layer, rename its layer to BG Texture, and then go to Edit > Transform > Rotate 90° Counter Clockwise.

Go to Image > Adjustments > Desaturate, and then change the BG Texture layer’s Blend Mode to Color Burn, and its Opacity to 5%.

After that, resize the texture as needed. You can change the Opacity value depending on how much texture you want the background to have.

Add the Background Texture

2. How to Create Text Layers

Step 1

Create the text in All Caps using the font Museo Sans Rounded 1000.

Set the Color to #ff0000 (or any other color you like), the Size to 250 pt, and the Tracking to 100.

Create the Text

Step 2

Duplicate the text layer, and change the copy’s Fill value to 0.

Duplicate the Text Layer

3. How to Create a Simple Extrusion

Step 1

Duplicate the original text layer, and drag the copy below the original.

Pick the Move Tool, and then press the Left Arrow key once and the Down Arrow key once, to nudge the copy layer 1 px in those directions.

Nudge the Text Layer

Step 2

Duplicate the nudged layer, place the copy below it, and then nudge the copy 1 px in the same directions. Place both nudged layers in a group and call it Extrusion.

The Extrusion Group

4. How to Create a Simple Semi-Transparent Style

Double-click the original text layer to apply the following layer style:

Step 1

Add a Bevel and Emboss with these settings:

  • Size: 3
  • Uncheck the Use Global Light box
  • Angle: -175
  • Altitude: 26
  • Gloss Contour: Guassian – Inverse
  • Check the Anti-aliased box
  • Highlight Mode: Vivid Light
    • Shadow Mode: Color Burn
      Bevel and Emboss

      Step 2

      Add a Contour with these settings:

      • Contour: Rolling Slope – Descending
      • Check the Anti-aliased box.
      • Range: 100%
      Contour

      Step 3

      Change the original text layer’s Fill value to 50%. You can hide the Extrusion group by clicking the eye icon next to it to see the results.

      Change the Fill Value

      5. How to Create a Textured Semi-Transparent Layer Style

      Double-click the copy text layer to apply the following layer style:

      Step 1

      Add a Bevel and Emboss with these settings:

      • Size: 8
      • Uncheck the Use Global Light box
      • Angle: 126
      • Altitude: 42
      • Gloss Contour: Cove – Deep
      • Check the Anti-aliased box
      • Highlight Mode: Vivid Light
        • Color: #b6b6b6
        • Opacity: 100%
      • Shadow Mode: Color Burn
        • Color: #010101
      Bevel and Emboss

      Step 2

      Add a Contour with these settings:

      • Contour: Cove – Shallow
      • Check the Anti-aliased box.
      • Range: 44%
      Contour

      Step 3

      Add a Texture with these settings:

      • Pattern: Texture Pattern 2
      • Depth: 4%
      Texture

      Step 4

      Add an Inner Shadow with these settings:

      • Opacity: 15%
      • Uncheck the Use Global Light box
      • Angle: 140
      • Distance: 6
      • Choke: 6
      • Size: 32
      • Contour: Cove – Deep
      Inner Shadow

      Step 5

      Add an Inner Glow with these settings:

      • Blend Mode: Vivid Light
      • Opacity: 5%
      • Color: #d1d1d1
      • Size: 55
      Inner Glow

      Step 6

      Add a Gradient Overlay with these settings:

      • Blend Mode: Soft Light
      • Opacity: 35%
      • Use a Black to White gradient fill
      Gradient Overlay

      Step 7

      You can also go back to the Texture effect and click-drag to move the pattern if you like.

      Move the Texture

      6. How to Style a Semi-Transparent Extrusion

      Double-click the Extrusion group to apply the following layer style:

      Step 1

      Add a Bevel and Emboss with these settings:

      • Size: 10
      • Uncheck the Use Global Light box
      • Angle: 6
      • Altitude: 37
      • Gloss Contour: Rounded Steps
      • Check the Anti-aliased box
      • Shadow Mode: Color Burn
        • Color: #8b8b8b
        • Opacity: 10%
      Bevel and Emboss

      Step 2

      Add a Contour with these settings:

      • Contour: Gaussian
      • Check the Anti-aliased box.
      • Range: 100%
      Contour

      Step 3

      Add a Texture with these settings:

      • Pattern: Texture Pattern 2
      • Depth: 7%
      Texture

      Step 4

      Add an Inner Shadow with these settings:

      • Opacity: 35%
      • Uncheck the Use Global Light box
      • Angle: 141
      • Distance: 9
      • Choke: 6
      • Size: 18
      • Contour: Rolling Slope – Descending
      Inner Shadow

      Step 5

      Change the Extrusion group’s Fill value to 38%.

      Change the Fill Value

      7. How to Create Stick Shapes

      Step 1

      Pick the Rectangle Tool, and then create a stick shape for the first letter you have on top of the Extrusion layer.

      Create a Stick Shape

      Step 2

      Pick the Ellipse Tool and create an ellipse for the stick’s tip on one side, and then duplicate the ellipse for the other side of the stick.

      Create the Sticks Tips

      Step 3

      Select all the stick shape layers, and then go to Layer > Merge Shapes and rename the shape layer to Stick, and add the letter’s name to it to keep things organized.

      Merge Shapes

      8. How to Style a Stick Shape

      Double-click the Stick shape layer to apply the following layer style:

      Step 1

      Add a Gradient Overlay with these settings:

      • Opacity: 77%
      • Style: Reflected
      • Angle: 0
      • Scale: 150%
      • Create the Gradient using the colors #ffffff to the left and #d8d8d7 to the right.
      Gradient Overlay

      Step 2

      Add a Pattern Overlay with these settings:

      • Pattern: Brushed Alum Dark
      Pattern Overlay

      Step 3

      Duplicate the styled Stick layer to add one for each letter, rename the copy layers, and group them in a Sticks group.

      Create the Sticks Group

      9. How to Add Shadows

      Step 1

      Use the Elliptical Marquee Tool to create a small ellipse where the stick meets the first letter.

      Create a new layer, call it Shadow and add the letter’s name to it, and then fill the selection with Black.

      Create the Shadow Fill

      Step 2

      Press Command-D to deselect, go to Filter > Blur > Gaussian Blur, and set the Radius to 3, or any other value depending on how much you want to soften the shadow.

      Gaussian Blur

      Step 3

      You can then change the layer’s Opacity, and transform the shadow until you get a result you like.

      Adjust the Shadow

      Step 4

      Duplicate the Shadow layer to add it to the other letters you have, and rename the copy layers.

      Duplicate the Shadow Layer

      Step 5

      Repeat the same steps to create a drop shadow below each letter.

      Use the color #454545, and change the layers’ Blend Mode to Color Burn and their Opacity to 7%.

      Create a Drop Shadow

      10. How to Add a Bubbles Texturing

      Step 1

      Place the WaterSplashes0119 texture on top of the Sticks group, rename its layer to Bubbles with the first letter’s name, and change its Blend Mode to Linear Burn and its Opacity to 70%.

      Scale the texture down to a bubble size you like.

      Add the Bubbles Texture

      Step 2

      Add a Levels adjustment layer, and clip it to the Bubbles layer you have.

      Click the Sample in image to set white point icon, and then click on the slightly darker areas to brighten the texture.

      You can click over different areas until you get a result you like.

      Brighten the Texture

      Step 3

      Command-click the text layer’s thumbnail to create a selection.

      Create a Selection

      Step 4

      Pick the Rectangular Marquee Tool, then press-hold the Shift-Option keys to intersect, and create a rectangle around the first letter you have.

      Intersect the Selections

      Step 5

      With the Bubbles layer selected, click the Add layer mask icon at the bottom of the Layers panel.

      Add a Layer Mask

      11. How to Edit a Texture Inside a Mask

      Step 1

      Click the link icon between the layer and mask thumbnails to unlink them.

      Unlink the Layer and the Mask

      Step 2

      Make sure that the layer’s thumbnail is selected, and use the Move Tool to move the texture around inside the layer mask, until you like the placement of the bubbles inside the first letter.

      Move the Bubbles

      Step 3

      Pick the Brush Tool, set the Foreground Color to Black, select the Bubbles layer mask’s thumbnail, and use a soft round tip to paint and mask any unwanted areas of the texture.

      Mask Unwanted Areas

      Step 4

      Repeat that for the other letters you have, and place the Bubbles and Levels layers in a Bubbles group.

      Create a Bubbles Group

      12. How to Add Texture Overlays

      Step 1

      Place the Water Texture image on top of all layers, rename its layer to Texture Overlay 1, and resize it as needed.

      Go to Image > Adjustments > Desaturate.

      Add the First Texture Overlay

      Step 2

      Command-click the original text layer’s thumbnail to create a selection.

      Then, press-hold the Shift-Command keys, and click each of the Extrusion text layers’ thumbnails to add to the selection.

      Create a Selection

      Step 3

      Add a layer mask to the Texture Overlay 1 layer.

      Add a Layer Mask

      Step 4

      Change the Texture Overlay 1 layer’s Blend Mode to Soft Light and its Opacity to 80%.

      Adjust the Texture Overlay

      Step 5

      Add the Water Stock II texture on top of all layers, resize it as needed, rename its layer to Texture Overlay 2, and press Command-I to invert its colors.

      Add the Second Texture Overlay

      Step 6

      Press-hold the Option key, then click-drag the Texture Overlay 1 layer mask to the Texture Overlay 2 layer.

      Change the Texture Overlay 2 layer’s Blend Mode to Soft Light and its Opacity to 25%.

      Adjust the Texture Overlay

      13. How to Modify a Scratches Texture

      Step 1

      Open the 11 texture image in Photoshop, Then go to Filter > Distort > Polar Coordinates, and use the Rectangular to Polar option.

      Polar Coordinates Filter

      Step 2

      Press Command-A, then Command-C to copy the image.

      Copy the Image

      Step 3

      Go back to the original document, and press Command-V to paste the image. Rename the layer to Scratches with the first letter’s name.

      Create the Scratches Layer

      Step 4

      Use the same Texture Overlay mask for the Scratches layer, and unlink it.

      Apply the Layer Mask

      14. How to Apply a Scratches Texture

      Step 1

      Duplicate the Scratches layer to create a copy for each letter you have, and rename the copies to add the letters’ names

      After that, for each letter, select its Scratches layer, and then use the Rectangular Marquee Tool to select the other letters, and fill the mask with Black to hide them.

      Adjust the Layer Masks

      Step 2

      Move each texture so that its center is in its letter’s center, and resize it if you like.

      Then, change the Scratches layer’s Blend Mode to Linear Burn and their Opacity values to 25%.

      When you’re done, add all the Scratches layers to a Scratches group.

      Create a Scratches Group

      15. How to Apply Filters and Adjust the Final Coloring

      Step 1

      Create a new layer on top of all layers, and then press the Shift-Option-Command-E keys to create a stamp.

      Rename the stamp layer to High Pass, and then right-click it and choose Convert to Smart Object.

      Convert to a Smart Object

      Step 2

      Go to Filter > Other > High Pass, and change the Radius to 1.

      High Pass Filter

      Step 3

      Change the High Pass layer’s Blend Mode to Soft Light.

      Blend Mode

      Step 4

      Set the Foreground and Background Colors to Black and White, and then go to Filter > Noise > Add Noise.

      Change the Amount to 1.35 and the Distribution to Gaussian, and then check the Monochromatic box.

      Add Noise Filter

      Step 5

      Finally, add a Gradient Map adjustment layer on top of all layers.

      Use the gradient fill below, and then check the Dither box, and change the layer’s Blend Mode to Soft Light.

      Gradient Map

      Congratulations! You’re Done

      In this tutorial we created a simple background using a gradient fill and a texture.

      Then, we created the text and extrusion layers, and styled them to achieve the main lollipop effect. After that, we used shapes and selections to create the sticks and shadows, and used layer styles and filters to add them to the styled text.

      Finally, we used a bunch of textures and filters to add more details to the effect, and make it look more realistic.

      Please feel free to leave your comments, suggestions, and outcomes below.

      Final Result
      View Tutorial: How to Create a Lollipop Inspired Text Effect in Adobe Photoshop

      50 Best Social Media Icon Sets for Web, Apps, and More

      Now more than ever, it’s important to be connected with the world. And with social media, creative professionals can link up with fans, clients, and new prospective audiences in a matter of seconds. So update your social media with this collection of 5…

      View Tutorial: 50 Best Social Media Icon Sets for Web, Apps, and More

      Frequency Separation Photoshop Tutorial (Nondestructive & Fully Editable Layers)

      Learn how to retouch skin in Photoshop with a technique called frequency separation. In this tutorial, you’ll learn how to apply frequency separation with a fully editable and nondestructive layer setup. This will let you readjust the settings or even make changes to your original layer without having to redo every single step. Frequency separation […]

      The post Frequency Separation Photoshop Tutorial (Nondestructive & Fully Editable Layers) appeared first on Photoshop Tutorials.

      View Tutorial: Frequency Separation Photoshop Tutorial (Nondestructive & Fully Editable Layers)

      Illustrator in 60 Seconds: How to Create a Phone Icon

      Welcome to our
      Illustrator in 60 Seconds series, in which you can learn an Illustrator skill,
      feature, or technique in just a minute!

      Illustrator in 60
      Seconds: How to Create a Phone Icon

      In today’s tutorial we’re going to show you how to create your very own phone icon using nothing more than simple shapes and tools that you probably already work with on a daily basis.

       

      How to Create a Phone Icon

      Step 1

      Start by creating a new web document with a 128 x 128 px artboard, which we’ll structure using two separate layers. Select the first layer, and add a 120 x 120 px circle which we’ll color using yellow.

      Crate a Circle

      Step 2

      And then align it in the center, locking its layer. Create the phone’s main shape using a white 48 x 84 px rounded rectangle with a 6 px corner radius, which we’ll position in the center of the artboard.

      Add a rounded rectangle

      Step 3

      Using the Rectangle Tool, add a display by drawing a 40 x 58 px shape, which we’ll color using yellow and then center align to the phone’s body, pushing it a few pixels toward the top afterwards. Add the lower button, using a yellow 8 x 8 px circle which we’ll center align to the phone’s chin. 

      Finish off the icon by creating the phone’s earpiece, using a 12 x 2 px rounded rectangle with a 1 px corner radius, which we’ll then center align to the upper section of its body.

      Add further shapes

      A Bit More Detail

      Learn more about Adobe Illustrator on
      Envato Tuts+:

      60 Seconds?!

      This is part of a series of quick video
      tutorials
       on Envato Tuts+ in which we introduce a
      range of subjects, all in 60 seconds—just enough to whet your appetite. Let us know
      in the comments what you thought of this video and what else you’d like to see
      explained in 60 seconds!

      View Tutorial: Illustrator in 60 Seconds: How to Create a Phone Icon

      How to Create Textured, Geometric Objects in Adobe Photoshop

      What You’ll Be CreatingGeometric objects are all the rage in the design industry today. And you can create interesting designs with a few simple shapes in Adobe Photoshop. Learn how to create these cool elements and convert them to Smart Objects b…

      View Tutorial: How to Create Textured, Geometric Objects in Adobe Photoshop