Word painting on canvas

All rights to paintings and other images found on PaintingValley.com are owned by their respective owners (authors, artists), and the Administration of the website doesn’t bear responsibility for their use. All the materials are intended for educational purposes only. If you consider that any of the materials violates your rights, and you do not want your material to be displayed on this website, please get in touch with us via «contact us» page and your copyrighted material will be immediately removed.

As quoted by Rudyard Kipling, “words are the most powerful drug used by mankind”, they have more effect on the minds when pictured and portrayed in enthralling ways. One such method to do so is to make use of a technique known as word art or typography. Typography is the art of using the words in a fashion that makes them more look more meaningful and appealing. Also, here we present some Creative Typography Art Design Which Are Best For Everyone.

In order to use the power of word art to the fullest, various types of backgrounds or canvases are used along. The canvas not only gives a good looking effect but also provides a gist about what the word is trying to depict. So whenever you want to try word art, keep in mind the importance of the canvas on which it is to be depicted. Let’s explore some of the Brilliant Word Art Canvas Design Examples that are in focus these days.

The power of quote!

The more appealing the canvas, the more long-lasting is the effect of the quote written on it. For such word art techniques involving the depiction of quotes, special type of canvases are designed and used. It is observed that the quote has a long-lasting effect on the reader when it is written on a well-matched background. So to make the quote more efficacious, make sure to use a canvas with a theme that matches with the theme or the gist of the quote. For instance, if the quote is about paths, then make use of canvas that depicts a road, path or an avenue. So, choose wisely and make the quote more effectual.

Face- an open book!

Typography Typeface Art is another important aspect of Brilliant Word Art Canvas Design Examples. In this theme, faces are created by taking the help of words having the same font. The typeface portraits are in trend these days. This is one of the most challenging styles of word art. Solid colored background or canvases are used to illustrate such artworks. Generally, a black or dark-colored canvas is preferred in order to give a more intense look.

Figures, figures all over!

When it comes to depicting something extremely simple but more figurative, geometric shape prints are the best to go with. Canvases with geometric prints are extremely easy to design. It becomes more fascinating when simple fonts are used for creating word art on a geometric print background. Ensure that you use simple shapes for the background and color them with eye-catching colors. Generally, black color is used to write on such canvases so that the artwork doesn’t look gaudy to the eyes.

Into the depths!

Who doesn’t like it when something is portrayed using three dimensions?! Doesn’t it seem to be more captivating than the usual 2D designs? An extremely engrossing and appealing word art theme is the 3D typography. Adding the third dimension i.e. depth, makes the object look more realistic. For such types of illustrations, simple but generally vibrant canvases are used. To add more life to the word art, make use of outlines for the words. Algerian, Broadway, Ravie, etc. are some of the best fonts that can be used to illustrate 3D word art.

If you believe you have that artistic stint which needs some polishing, here we bring you New Canvas Painting Ideas to Learn From.

The streets witness it all!

Walls are the keys to the streets! Walls describes a lot about the streets and the locality. It is said walls are the biggest weapon for a revolution to take place. We say many quotes, write-ups on the walls these days when we pass by the local streets. Street art has become a means to convey various messages on some issues of serious concerns. It began with writing alphabets, characters, numbers, names, and symbols on the walls and has grown into quotes today. Selecting a street word art canvas can be a good option to convey your thoughts.

From the foregone era!

A vintage background for a word art canvas is a perfect match! Use vintage or retro kind of theme and give your artwork an essence of whilom memories. Such background gives rise to an elegant work. Make this depiction look more appealing by making the use of various vintage fonts like Bobel, Campanile, Deftone Stylus, Fletcher Gothic, and Secesja, etc. So, select a perfect vintage canvas for your art and travel back into the fallen era of loving memories!

Say it with the logo!

This type of canvas is generally used for illustrating logos. The background for such artwork is kept solid colored. This is done so that the logo is highlighted better than the canvas itself. It also helps in showcasing the details in the logo. The colors of the text and the canvas are selected in contrast in order to make the differentiation of the text from the background visible. For instance, if the text of the logo is to be colored with a dark shade, then the color of the canvas should be any lighter shade.

If you are enough curious to know what art varieties can be created using fall leaves, then read on. Here you find some of the most Creative ways to turn fall leaf into art.

Caught with the colours!

Grab it all with your colors! Colors are the main ingredients in any art that allows the thoughts of the artist to reach and connect to the spectators. Shades are the means of the artists, to reach the spectator’s mind, heart or soul. This type of typographic canvas uses vibrant colors to make the art appear catchy to the eyes. Such type of canvases can be used for artworks related that can be installed in a hotel, school, etc.

If you are a beginner and looking for some tips and tricks, here we are to help solve your worries with these Abstract Painting Ideas For Beginners. Keep reading and discover the world of abstract painting

Force your imagination and try creating new canvases other than those mentioned above and allure the spectators by trying these Brilliant Word Art Canvas Design Examples.

There used to be another answer here that got deleted because it was a link only. The original link is here. The code is basically the same, but I took out the non text drawing portions and also scaled up the sizes to work better on modern screen densities.

This just shows a few things you can do with text drawing.

Here is the updated code:

public class MainActivity extends AppCompatActivity {

    DemoView demoview;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        demoview = new DemoView(this);
        setContentView(demoview);
    }

    private class DemoView extends View {
        public DemoView(Context context){
            super(context);
        }

        @Override protected void onDraw(Canvas canvas) {
            super.onDraw(canvas);

            // custom drawing code here
            // remember: y increases from top to bottom
            // x increases from left to right
            int x = 0;
            int y = 0;
            Paint paint = new Paint();
            paint.setStyle(Paint.Style.FILL);

            canvas.save();
            canvas.translate(100, 200);

            // make the entire canvas white
            canvas.drawColor(Color.WHITE);

            // draw some text using STROKE style
            paint.setStyle(Paint.Style.STROKE);
            paint.setStrokeWidth(1);
            paint.setColor(Color.MAGENTA);
            paint.setTextSize(100);
            canvas.drawText("Style.STROKE", 0, 0, paint);

            canvas.translate(0, 200);

            // draw some text using FILL style
            paint.setStyle(Paint.Style.FILL);
            //turn antialiasing on
            paint.setAntiAlias(true);
            //paint.setTextSize(30);
            canvas.drawText("Style.FILL", 0, 0, paint);

            canvas.translate(0, 200);

            // draw some rotated text
            // get text width and height
            // set desired drawing location
            x = 75;
            y = 185;
            paint.setColor(Color.GRAY);
            //paint.setTextSize(25);
            String str2rotate = "Rotated!";

            // draw bounding rect before rotating text
            Rect rect = new Rect();
            paint.getTextBounds(str2rotate, 0, str2rotate.length(), rect);
            canvas.translate(x, y);
            paint.setStyle(Paint.Style.FILL);
            // draw unrotated text
            canvas.drawText("!Rotated", 0, 0, paint);
            paint.setStyle(Paint.Style.STROKE);
            canvas.drawRect(rect, paint);
            // undo the translate
            canvas.translate(-x, -y);

            // rotate the canvas on center of the text to draw
            canvas.rotate(-45, x + rect.exactCenterX(),
                    y + rect.exactCenterY());
            // draw the rotated text
            paint.setStyle(Paint.Style.FILL);
            canvas.drawText(str2rotate, x, y, paint);

            //undo the translation and rotation
            canvas.restore();
        }
    }
}

Something else that I want to try later is drawing text along a path.

See also this fuller answer here that gives the following image.

We can use TLabel to show any text just to show any text, not editing. But what could we do to show text on a canvas? Then we would need to draw the text. Here’s how…

For showing any normal text that doesn’t usually react to any user events, which only lies idle on the form can be made by using a TLabel. We use TLabels for captions for input fields and instructions to how to use the program we have made.

Printing your text on a Canvas

TLabel is for forms, right? But what about if we want text on a Canvas. We cannot actually put a TLabel on a Canvas! Sure we can place them over a component which has a canvas, but it is not really being printed into the canvas. And don’t even get me started on invisible virtual canvases (Canvases of image variables, such as TBitmap.Canvas). It is not possible to use TLabels on that. If we want our text to be printed on a Canvas we need to use procedures like TextOut() and TextRect(). And if we are in the mood of experimenting, we can also try DrawText() procedure from LCL. But I prefer something from the canvas itself.

Examples of drawing text on a Canvas

To run these examples, you may need to create an Application Project (Project-> New Project-> Application-> OK) and then enter these codes on the form’s onPaint Event (Object Inspector-> Events-> OnPaint-> […]).

Example 1: Text at the top left corner

We use the Tcanvas.TextOut procedure to draw text.

begin
  Canvas.TextOut(0,0,'Hello');
end;

The text will be printed on the form’s canvas in the top left position (0,0…).

Example 2: Text at a certain position

begin
  Canvas.TextOut(80,60,'Hello');
end;

The text will be drawn at 50 pixels from left and 60 pixels to the right.

Example 3: Text and background color

By default the text is drawn with white background and with black text color. The colors are set as a default for canvas. But we can change that…

begin
  Canvas.Brush.Color:=RGBToColor(0,166,81);
  Canvas.Font.Color:=RGBToColor(255,255,255);
  Canvas.TextOut(80,60,'Hello World');
end;

The background is set by Brush.Color and the text color is set by Font.Color. You can also set any TColor as a value, such as clGreen, clBlack, clWhite etc.

Example 4: Text without no background

We can draw text with transparent background (or in other words, eliminate the background color).

begin
  Canvas.Brush.Style:=bsClear;
  Canvas.TextOut(80,60,'Hello World');
end;

Example 5: Setting text size

Now we need to change the font size, because it looks tiny in our form!

begin
  Canvas.Font.Size:=18;
  Canvas.TextOut(80,60,'Hello World');
end;

Example 6: Getting the text size before drawing (and drawing a rectangle around it as border)

We can even get the width and height of the area which the text would take to be drawn. For example, it can determine how much vertical space it would going to take to draw a text even with a specific font size. We can do it before we have done our drawing of text.

var
  ww, hh: Integer;
begin
  Canvas.Font.Size:=18;
  Canvas.Font.Color:=clRed;
  Canvas.Brush.Style:=bsClear;

  ww:=Canvas.TextWidth('Hello World');
  hh:=Canvas.TextHeight('Hello World');
  //// Or...
  //Canvas.GetTextSize('Hello World', ww, hh);

  Canvas.Rectangle(80, 60, 80+ww, 60+hh);
  Canvas.TextOut(80,60,'Hello World');
end;

Canvas.TextWidth returns the width and Canvas.TextHeight returns the height of the probable drawing area before actually printing the text. We can also use Canvas.GetTextSize, which assigns the width and height to the variables given (without returning anything).

Example 7: Center a text

If we can get the area in which the text is going to be drawn, then we can obviously draw the text on the center.

var
  ww, hh: Integer;
begin
  Canvas.Font.Size:=18;
  Canvas.Font.Color:=clRed;
  Canvas.Brush.Style:=bsClear;

  Canvas.GetTextSize('Hello World', ww, hh);

  Canvas.TextOut((Width-ww) div 2, (Height-hh) div 2, 'Hello World');
end;

Example 8: Drawing text in a rectangular area (good for paragraphs)

Now we will see how to draw text inside a specific rectangular area.

var
  textarea: TRect;
  mytext: string;
  mytextstyle: TTextStyle;
begin
  Canvas.Font.Size:=14;
  Canvas.Font.Color:=clRed;
  Canvas.Brush.Color:=clBlack;

  mytext:=’Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer nec odio. Praesent libero. Sed cursus ante dapibus diam. Sed nisi. Nulla quis sem at nibh elementum imperdiet. Duis sagittis ipsum. Praesent mauris. Fusce nec tellus sed augue semper porta. Mauris massa. Vestibulum lacinia arcu eget nulla. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Curabitur sodales ligula in libero. Sed dignissim lacinia nunc. Curabitur tortor. Pellentesque nibh. Aenean quam. In scelerisque sem at dolor.’;
  textarea:=Rect(0, 0, 250, 400);
  mytextstyle := Canvas.TextStyle;
  mytextstyle.Wordbreak:=True;
  mytextstyle.SingleLine:=False;

  Canvas.TextRect(textarea, 20, 20, mytext, mytextstyle);
  Canvas.FrameRect(20, 20, textarea.Right, textarea.Bottom);
end;

We set the the Brush.color for the FrameRect procedure later on, which will draw a rectangle showing the area in which we have drawn the text. We define a TRect to define the area in which we want our text to be shown. We use a variable mytextstyle to tweak the drawing rules for our text. We set wordbreak to True and SingleLine to False just to indicate that we want to have our text not in a single line but in a paragraph style inside the TRect. Be my guest and comment out the 2 lines to see what happens if we wouldn’t have written these lines.

Sample Project

We have learned quite a bit from the examples above. Now we would create a sample application to demonstrate the usability of the code. We would make a graphical interface to choose text, font, font size, font color and finally drawing area for the text. This is already a huge post, so I will go through the project creation in short.

Create a new Application project (Project-> New Project-> Application-> OK).

Create components and name them seeing the screenshot below of the Object Inspector.

The form layout would be something like this: If you don’t find a component then use Ctrl+Alt+P (or View-> Components) to find that naughty little component that was hiding from you.

At the top we have edtText. Change its default Text property to something like «This is a sample text».
Then its the cboFonts. Set its Style property to csDropDownList. Set it also for the cboSize. For cboSize, set its Items property with variaous font sizes, such as:
8
10
12
14
16
18
24
36
Then set its ItemIndex to 0. The Text property will be automatically changed.

For sel, the selection rectangle, set its Pen->Color to clRed and Pen->Style to psDot.

Now add these variables under the first var that appears in the code (usually after Form1: TForm1; line). You can switch between code and form view by pressing F12.

  PrevX, PrevY: Integer;
  Clicked: Boolean = False;

  bmp1: TBitmap;

Double click the form and enter:

begin

  // we list all the fonts in the TComboBox
  cboFonts.Items := Screen.Fonts;
  cboFonts.ItemIndex:=0;

  bmp1 := TBitmap.Create;

  bmp1.SetSize(Screen.Width, Screen.Height);
  bmp1.Canvas.FillRect(0,0,screen.Width,screen.Height);
end;

Now add these codes in the OnClose event of the form (select the form, then go to Object Inspector-> Events-> OnClick-> […]).

begin
  bmp1.Free;
end;

On Paintbox1’s OnMouseDown event enter:

procedure TForm1.PaintBox1MouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);

begin
  if Button = mbLeft then begin
    PrevX:=X;
    PrevY:=Y;

    // so that it doesn't appear with the previous size
    // that was made with dragging
    sel.SetBounds(0,0,1,1);
    sel.Visible:=True;

    Clicked:=True;
  end;
end;

On Paintbox1’s OnMouseMove event enter:

procedure TForm1.PaintBox1MouseMove(Sender: TObject; Shift: TShiftState; X,
  Y: Integer);

begin
  if Clicked = true then begin
     sel.left  := PaintBox1.Left+PrevX;
     sel.top   := PaintBox1.Top+PrevY;
     sel.Width := X - PrevX;
     sel.Height:= Y - PrevY;
  end;
end;

On Paintbox1’s OnMouseUp event enter:

procedure TForm1.PaintBox1MouseUp(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
var
  textarea: TRect;
  mytext: string;
  mytextstyle: TTextStyle;
begin

  if Clicked = true then begin

    Clicked:=False;
    sel.Visible:=false;

    bmp1.Canvas.Font.Name:=cboFonts.Text;
    bmp1.Canvas.Font.Size:=StrToInt(cboSize.Text);
    bmp1.Canvas.Font.Color:=ColorButton1.ButtonColor;

    mytext:=edtText.Text;
    textarea:=Rect(0, 0, X, Y);
    mytextstyle := bmp1.Canvas.TextStyle;
    mytextstyle.Wordbreak:=True;
    mytextstyle.SingleLine:=False;

    bmp1.Canvas.TextRect(textarea, PrevX, PrevY, mytext, mytextstyle);
    PaintBox1Paint(Sender);

  end;

end;

Now, Run it (F9 or Run-> Run).

Now choose a font, size, color, text and then drag a rectangular area on the Paintbox to your text drawn on it. Simple!

Download Sample Code ZIP

You can download an example source code zip file from here
Or here: http://bit.ly/12ftOdL
Size: 528 KB
The package contains compiled executable EXE file.

Ref:
http://www.lazarus.freepascal.org/index.php?topic=21118.0
http://msdn.microsoft.com/en-us/library/aa911421.aspx
http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/delphivclwin32/Graphics_TCanvas_TextRect@TRect@Integer@Integer@string.html

In this article I share 3 more easy ways that you can add your favorite words, quotes, sayings, or lyrics to canvas. To get started, you’ll need stretched canvas. I like to use a high quality canvas that is stapled on the back rather than the sides, like this Winsor Newton canvas. Next, you’ll need paint. I find that acrylic paint works best because it dries quickly. You can also use spray paint for some of these projects (I like Krylon brand spray paint best). Finally, I recommend using a finishing spray once you’re painting is done to protect it. I use Krylon finishing spray which comes in glossy, satin, and matte (satin is my favorite!).

1. Collage

A fool-proof way to place letters onto a canvas is to attach them collage-style. This style provides a clean look for your painting and is great if you don’t want to hand paint letters. You can use letters or words from a magazine or pamphlet, print out words, or use letter stickers. You can even cut letters out of interesting materials, like wallpaper samples or maps!

Pros: Easy, adds texture

Cons: Longer dry-time, limited with size, colors, and shapes of lettering

What you need:

• 

  Mod Podge (comes in matte or glossy)

• A foam brush
• Letter stickers or cut outs

How to:

1. Paint your canvas the background color of your choice. Make sure the color contrasts with the colors of your letters. Let it dry completely.

2. Place your letters or words on the canvas and check their placement.

3. Coat the back of each letter with Mod Podge and stick it to the canvas. Layer another coat of Mod Podge on top. It will look like a white mess, but I promise- it will dry clear! Let the canvas dry.

4. Layer another coat of Mod Podge over the letters to seal any edges and let it dry. You may need to do this once more to ensure the edges won’t peel up depending on how thick your lettering is.

5. Seal your painting with a finishing spray (optional). The Mod Podge acts like a sealing coat, but I like to use the spray finish at the end to fill in any brush strokes that may be left and make the painting appear more even.

 2. Stickers

In my last DIY I explained one way to use stickers to create lettering on canvas. This technique is a little different- I like to call it “reverse stickering.” It gives the canvas a much different look than the other technique, and enables you to create texture and add different colors .

Pros: Simple, creates more texture

Cons: Letters are limited to the size and shape of the stickers

What you’ll need:

• Vinyl letter stickers (Be sure they don’t say permanent. I use these.)
• Paint brush

How to do it:

1. Paint the background of your canvas and let it dry.

2. Stick your letter stickers on the canvas.

3. Carefully paint over your letter stickers. Be sure not to use hard brush strokes or you might move the stickers. Don’t be afraid to experiment with different directions of your brush strokes and thickness’s of your paint! Let your canvas dry.

4. Peel the stickers off the canvas carefully, being sure not to remove any paint. (Tip: you can use an old pair of tweezers to help you remove the stickers).

3. Paint Markers

Paint pens work well if you enjoy handwriting or calligraphy and want to transfer your words to canvas in your own handwriting. They also works wonderfully if you have a lot of writing or very small print to transfer. If it sounds too intimidating to write directly on your canvas, not to worry– you can sketch your lettering on paper or print words from the computer and transfer it to your canvas.

Pros: Quicker than hand painting letters, more control over the size and placement of lettering

Cons: Less choice with color, easier to mess up!

What you’ll need:

• A paint marker in the color of your choice (I use Tree House Studio brand markers, which I find at Hobby Lobby and come in a variety of colors and sizes)
• Carbon paper and regular paper
• A ruler
• Tape
• A pencil and a ball point pen

How to do it:

1. Paint your canvas in the background color of your choice and let it dry

2. If you’re going to sketch your lettering first, you’ll be using the same method I outlined in my last DIY article. Use your ruler to measure the size you want the lettering on the canvas and make appropriate sized lines to guide you on a piece of paper. Draw out your lettering on the paper.

3. Place a piece of carbon paper face down on the canvas, place your paper with your lettering on top, and tape it down. Make sure your tape the paper in the position you’d like the lettering- use a ruler to make sure it’s centered.

4. Trace over the letters using a ball point pen, pressing firmly. Untape the paper and carbon paper to reveal your transfer.

3. Using the paint pen, trace over your carbon transfer. If you’re using a white paint pen, you may find you’ll need two coats over the carbon transfer.

4. Seal the painting (optional).

So what do you think of these 3 ways to transfer lettering to canvas? Love them, hate them, can’t wait to try them? Leave me a comment and let me know what you think! And please share, like, pin, or post if you enjoyed this DIY!

In this article we’re going to explore several techniques that can be used to create textured text or apply a background to text.

Please remember that some of the techniques covered in the article are experimental with very low browser support, and may not be the best technique to use when you’re building real projects that need wide browser support.

I’ve included a screenshot for each demo, the link to the demo in the end of each technique. You can also click the screenshot to see the respective demo.

Applying an Image Background to Text Using
-webkit-background-clip: text

We’re going to start with the CSS background-clip property and use it to get the following result:

The CSS background-clip property determines an element’s background painting area, which is the area within which the background is painted. By default, the background extends all the way to the border of an element with a default value of border-box, and it can take other values like padding-box and content-box, which are self-explanatory.

Different effects, such as giving an element transparent borders, can be created using this property, and it is pretty well supported in all modern browsers.

The background-clip property was extended in Webkit with a fourth value, text, which causes the background image to clip to foreground text (including decorations and shadows). Then, by giving the text a transparent color using the Webkit-only property -webkit-text-fill-color, the background image will show through the text, thus completing the clipping effect.

The text value of the background-clip property is, at the time of writing of this article, not part of any standard yet, so unfortunately it can only work in WebKit browsers, and a simple CSS fallback can be provided for other browsers, or a polyfill could be used to provide other fallbacks.

For now, we’ll create a text with a background using the -webkit-background-clip property, and provide a CSS-only fallback which will show the image underneath the text for non-WebKit browsers.

For our demo (shown in the screenshot above), we have an element with a background and a headline inside it, and we want to clip its background to make it appear as if the background is only applied to the text inside it.

<div class="container">
	<!-- the element whose background we're going to clip -->
	<div class="clipped">
		<h1>CO<br/>OK</h1>
	</div>
	<!-- arbitrary content -->
	<p><span>The #1 cooking magazine in the world.</span> New healthy and delicious recipes every week. Subscribe to the weekly issue of COOK magazine and stay up-to-date on the latest kitchen trends and tips anc tricks from the world's #1 chefs. <br/>
	Download our app available for Android, iOS and Windows phones.</p>
</div>

We’re going to use a “fat font”, so that the background is more visible through the text. The .clipped element will get a background image, which we’ll clip to the text using the text value of the background-clip property. We’re going to set the text color to white, because non-WebKit browsers will display the text on top of the image and we need to pick a font color that would be readable on the background we chose. Then we’re going to set the text’s fill color to transparent, which will override the white text color in WebKit browsers so that the background image can show through.

.clipped {
	background: url(../img/kitchen.jpg) no-repeat center center;
	background-size: cover;
	color: #fff;
	text-align: center;
	padding: 2em;
	/* -webkit-background-clip clips the background of the element to the text */
	-webkit-text-fill-color: transparent; /* overrides the white text color in webkit browsers */
	-webkit-background-clip: text;
}

Check out demo 1: Text with Background using background-clip:text

If you’re viewing the demo in a non-WebKit browser, you will see a white text on top of a background image.

Displaying the background image behind the opaque text in non-WebKit browsers is probably the best fallback for when the image plays an important role in conveying a visual message, but you can also fall back to regular text without the image in the background, if you want. Divya Manian has written an excellent article explaining how to achieve that regular text fallback, and Rachel Nabors has created a Sass mixin based on Divya’s code and has made it available on Codepen for you to use if you want, too.

Now, just like we applied an image background to our text, you could also apply a gradient background to it. Because gradients in CSS are images you can apply a gradient to the .clipped element above, and the result will be a text with a gradient background. Riza Selçuk Saydam has created a very nice interactive step-by-step demo on Codepen which explains how a text gradient is made. You can check it out for a more visual explanation of this technique.

Applying Texture to Text Using mask-image: url();

The following CSS technique we’re going to go over is, at this time, also supported in WebKit browsers only (see support tables here) with the -webkit prefix.

We’re going to use CSS masks to create a nice textured text effect. CSS Masking is a W3C working draft, and so hopefully it won’t be long before other browsers also start implementing it.

But for now, we’re going to create a demo that will currently work in WebKit browsers only, and we’ll provide a simple fallback for non-supporting browsers. We’ll be using CSS’s mask-image property to apply a splatter effect to text to get the following result:

When we’re using CSS masks, we’re making the text take the shape of its mask image, instead of making the image take the shape of the text as with the background-clip technique above.

The mask-image property takes one of three values: an image with alpha opacity, where the transparent areas will be the areas where no content will show, a CSS gradient, or none. For our demo, we’ll be using an image with alpha opacity, which looks like the following:

The image represents a bunch of paint splatters that we want to apply to the text to make it look like it’s got some watercolor paint on it. Non-supporting browsers will simply display the text without the splatter effect applied to it.

When you apply this mask to your text, or to any other content, the text will be visible where the black splatters are, and the parts where the mask image is transparent the text will not show. You can imagine your text (or content) as a layer and the mask as another layer, and then imagine placing the mask image on top of the text, and then get an eraser and start erasing all the parts of the text that are not covered by those black spots, then you’ll end up with the masked text as shown in the demo’s screenshot above.

To make the effect more realistic, I added a watercolor background to the element containing that text, which will show through the text where it has been “erased”, therefore nicely blending the text with its background. All of this, using CSS only. Pretty neat, right? Too bad browser support is still very low at the moment. But we’ll go over recreating this effect to work cross-browser in the next section.

Now, for our demo, we have a container wrapping two headings:

<div class="container>
  <h1>Art</h1>
  <h2>Digital Magazine</h2>
</div>

We’ll be applying the splatter effect to the h1 element. Here’s the relevant CSS for our effect:

.container h1 {
	font: 35em/100% "Oswald", sans-serif;
	margin: 0 auto;
	padding: 0;
	text-align: center;
	color: #fff;
	/* the property that creates the splatter effect */
	-webkit-mask-image: url(../img/splatter-mask_1.png);
	mask-image: url(../img/splatter-mask_1.png); 
}

And that’s all you need to achieve that effect. Now, of course you’ll want to add some extra styling like I did in the demo, depending on the overall effect you’re after, but that one line of CSS is what’s important when you use a mask to add texture to text.

One important thing to note here is that when this property is implemented in other browsers, a -webkit- prefix may or may not be the only prefix you need. You need to add the -webkit- prefix for this to work at the time of writing of this article, and if you do use this technique in a project, make sure to update your code whenever the spec or browser support changes.

Check out demo 2: Textured Text using mask-image.

The demo will fall back to a regular text over an image in non-supporting browsers.

You can read more about CSS Masking in the W3C spec, and check another example of subtle textured text in this post by Trent Walton.

Creating textured text with SVG

Both of the previous effects can be recreated using SVG, and the best thing about it is that the results obtained with SVG are cross-browser, so you can use the SVG method as a fallback for non-supporting browsers for the above CSS properties.

Clipping A Background to Text using An SVG <clippath>

First, we’re going to recreate the CSS background-clip: text effect using SVG’s <clippath> element.

A clipping path determines the shape or region where the background is going to be applied. The parts of the background that lie outside the defined shape will not be painted, and only those inside the given shape will be.

A clipping path can take several values, one of which is a <text> element. When the clip path is set to a text element, the background will be clipped to the shape of the text used.

Once a clipping path is defined (we’ll get to the code in a minute), that path can be referenced using clip-path, either as an attribute of the image that we want to clip, or as a CSS property of that image.

Let’s start by defining the clip path that we want to use to clip our image, which in our case will be just a single word that we want our background image to show through.

First we create an SVG element which will contain all our SVG code. Then we’ll define our clip path and apply it to an image element via the clip-path attribute:

<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="1200" height="400" viewBox="0 0 1200 400"> 
    <!-- add title for accessibility -->
    <title>Adding Background to Text using SVG clipPath</title> 
    <defs>  
      <clippath id="my-path">
        <text x="50" y="300" font-size="200" >WATERCOLOR</text>
      </clippath>
    </defs>
    <image xlink:href="img/watercolor_1.jpg" clip-path="url(#test)" width="100%" height="100%" preserveAspectRatio="none" />
</svg>

Because an SVG element is basically a graphic, make sure to include a title so that it’s accessible by screen readers.

In the code above, we’ve created a text element, given it a font size, and defined the x and y coordinates which determine where the text will be drawn inside our SVG. Then, we’ve placed our text element inside a clippath element, which we’ve given an ID so that we’d be able to reference it. Then, we placed the clippath element inside a defs element. The defs element can be used to store content that will not be directly displayed. This stored hidden content can then be referenced and displayed by other SVG elements, which makes it ideal for things such as patterns that contain reusable graphics. And in our case, it’s perfect for defining our clip path that we want to reference in our image attribute.

Next, we added our image, gave it a width and a height, and set the preserveAspectRatio to none so that its aspect ratio does not get locked, because if it does, then the height and width won’t be applied to it if they don’t preserve its aspect ratio.

And last, we referenced the clipping path we defined by using the clip-path attribute on the image. The clip-path attribute takes the ID of the clippath element as its value, and applies the clipping path to the image.

Check out demo 3: Text background using SVG <clippath>.

Instead of applying the clip path to the image by referencing it with the clip-path attribute, you could also apply it via CSS like so:

image {
    clip-path: url(#my-path);
}

This should work as expected in all modern browsers: Chrome, Safari, Opera, Firefox and IE9+. So, if you do want to use the CSS background-clip: text; property you could, for example, check for browser support for background-clip: text using Modernizr, and provide the SVG as a fallback for non-supporting browsers, and this is kind of what Tim Pietrusky’s polyfill does, but instead of using a background image and clipping it using clippath, it uses an SVG pattern to fill the text with the background image that you would initially want to clip. In the next section, we’re going to go over filling a text with a pattern in SVG.

Applying a Background To Text By Filling It With An SVG <pattern>

So another way we could apply a background or pattern to text is by filling the text with a pattern, instead of using a background image and clipping it to the text. For this demo, we’re going to fill our text with a wooden pattern which I got from SubtlePatterns.

Using an image and clipping it to text could be a great choice for when you’re using decorative fonts like we did in our first demo, where we wanted a big portion of the image to show through the text, because the image plays a role in defining the character of our demo. But sometimes, all we want to do is just add a simple and subtle pattern to text to give it that extra nice touch which makes it less dull. In that case, using SVG, we can define a pattern just like we defined a clipping path in the previous section, and then we can use that pattern to fill the text with it.

Similar to the previous demo, we have an SVG element with a title added for accessibility, a text element which we want to fill with the pattern, and a defs element which we’re going to use to define our pattern. The pattern consists of an image and has an ID that we’ll be using when we want to reference it and apply it to our text. We’re going to reference the pattern inside the text’s fill attribute, or via the text’s CSS fill property.

<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="700" height="400" > 
	<!-- add title for accessibility -->
	<title>Applying a patterned background to text in SVG</title> -->
	<!-- Source: http://lea.verou.me/2012/05/text-masking-the-standards-way/ -->
	<defs>
		<pattern id="filler" patternUnits="userSpaceOnUse" width="400" height="400" >
			<image xlink:href="img/purty_wood.png" width="1200" height="600" preserveAspectRatio="none" />
		</pattern>
	</defs>
	<text x="100" y="70%" font-size="200" fill="url(#filler)">WOOD</text>
</svg>

And similar to the previous demo, you could reference the pattern via CSS like so:

text {
    fill: url(#filler);
}

See demo 4, which also works in all modern browsers, in action: Text background using SVG text fill with image.

At this point, it is worth noting that not only can you use an image as an SVG pattern, but because gradients are, as we mentioned before, also images, you can also create an SVG gradient and use that to fill the text, instead:

Creating and using a gradient in SVG is simple. A gradient is created as a radialGradient or linearGradient element, and is given an ID, and is then referenced in the fill attribute or CSS property like we did with the <pattern> above. Here’s a simple example where a gradient is used to fill the text.

Check out demo 5 that shows text being filled with a gradient.

And of course, a gradient can also be set as the container’s background image, and then we can clip the background using clippath just like we did in the previous section.

Applying Texture to Text Using an SVG <mask>

Just like we can apply an image mask to an element using the CSS mask-image property, we can also apply the same masking concepts and get the same effects using SVG masks.

An image with opaque and transparent areas would define where the element would be painted just like we saw in the previous section with the CSS mask-image property. There is one important difference, though, between CSS image masks and SVG image masks: SVG masks, unlike CSS masks, use the luminance values in a mask to determine what gets masked, not the alpha values. So an image that would be composed of black and transparent areas, for example, like the splatter mask we used above, would have to be replaced with an image composed of white and transparent areas. So, if we were to recreate the same splatter text effect that we created above, we would have to use a mask image that looks like the following:

>

An alpha channel image mask can be easily converted to a luminance image mask in Photoshop by applying a white color overlay which turns the black areas into white, and that is what I have done to replace the CSS image mask with this one suitable for SVG masks. The light gray areas visible in the above image are actually transparent, I just gave the image this background so you can see the white splatters which otherwise wouldn’t be visible on the white background of this post.

Now, just like we defined our SVG clipping path and pattern, we can define our mask in a similar way and apply it to our text.

We will create an image, wrapped inside an SVG mask element, which will get an ID so that it can be referenced, and the mask will be wrapped inside the defs element, which is used to define our mask without directly rendering it.

So it’s like saying: we’re defining (defs) an SVG mask (mask) which is an image (image) with the following URL (URL to the luminance mask above), and then we’ll apply this mask to our text using the mask attribute on the text element, or, of course, via CSS using the mask property.

<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="1000" height="380" > 
	<!-- add title for accessibility -->
	<title>Adding Texture to Text using SVG Masks</title>
		<defs>
			<mask id="mask">
				<image width="1200px" height="1200px" xlink:href="img/splatter-mask_luminance.png" preserveAspectRatio="none"/>
			</mask>
		</defs>
	<text x="50" y="70%" font-size="168" fill="white" mask="url(#mask)">WATERCOLOR</text>
</svg>

And to complete the effect, I added the watercolor background to the main svg element to make it look like the text is blended into that background.

Check out the cross-browser result in demo 6.

If you want you can read more about combining CSS and SVG masks in this excellent article by Christian Schaefer on The Nitty Gritty blog. There’s a lot more potential to SVG masking than this, as things can get quite interesting when you use animated Canvas-driven backgrounds, for example, as masks.

Creating textured text with HTML5 <canvas>

The last technique we’re going to go over uses the HTML5 <canvas> element to create the above effects. With <canvas>, you can also “clip” an element to the shape of another, “fill” text with texture, and apply a mask-like effect to text, by changing the value of the globalCompositeOperation property of the canvas context.

Before we get into the how of it, let’s define our markup, because it’s the same markup for the 3 techniques we’re going to cover.

We have a canvas element for which we specify a height and a width, and before the closing tag, we’re going to add a text content which will be available for screen readers to read, and for browsers that have JavaScript disabled to fall back to. One note here, though, is that Firefox does not display the text as a fallback for the canvas when JavaScript is disabled, which may be a bug.

<canvas id="canvas" width=1000 height=600 >
 
  WATER
</canvas>

Now that we have our markup ready, let’s start drawing some textured text!

For our first demo, we’re going to create a text on our canvas, and fill it with a pattern of our choice to get the following result:

We’re going to get our canvas element and its drawing context, and then we’re going to create an image, and use that image as the fill style for our text.

var canvas = document.getElementById("canvas");
var ctx = canvas.getContext("2d");
//create image we're going to use as a fill pattern
var img = document.createElement("img");
img.src="img/water.jpg";
//draw the text
img.onload= function(){
  drawText();
}
//function that draws the text and fills it with the texture from the img
function drawText() {
    ctx.font = "bold 200pt Oswald";
    ctx.fillStyle = ctx.createPattern(img, 'repeat');
    ctx.textAlign = 'center';
    var x = canvas.width / 2; 
    ctx.fillText("WATER", x, 400);
    ctx.fill();
}

So, let’s go over the above code. All the drawing happens inside a function drawText. We’re going to define the font style in the context’s font property, and then using the context’s createPattern method, we’re going to create a pattern out of the image we created before, and we’re going to set that pattern as the value for the fillStyle property, which determines, of course, the fill style for the font. And last but not least, we’re going to actually draw the text on the canvas using the fillText method, which takes a string which is the content of the text we want to draw, and a couple of x and y coordinates, which, as you may have guessed, determine where on the canvas the text will be painted.

Check out demo 7 in action.

There’s one thing to note here: when you’re using a custom font inside your canvas, you may not be able to see that custom font rendered, because the canvas drawing may happen before the font has been loaded. To work around this, you could, for example, use a font loader like the Web Font Loader developed by the Typekit and Google developers, and draw on the canvas after the font has been loaded:

WebFontConfig = {
	google: { families: [ 'Oswald' ] },
	fontactive: function() {
		var canvas = document.getElementById("canvas");
		var ctx = canvas.getContext("2d");
		var img = document.createElement("img");
		img.src="img/water.jpg";
		
		img.onload= function(){
			drawText();
		}

		function drawText() {
			ctx.font = "bold 200pt Oswald";
			ctx.fillStyle = ctx.createPattern(img, 'repeat');
			ctx.textAlign = 'center';
			var x = canvas.width / 2; 
			ctx.fillText("WATER", x, 400);
		}
	}
};
(function() {
	var wf = document.createElement('script');
	wf.src = ('https:' == document.location.protocol ? 'https' : 'http') +
	 '://ajax.googleapis.com/ajax/libs/webfont/1/webfont.js';
	wf.type = 'text/javascript';
	wf.async = 'true';
	var s = document.getElementsByTagName('script')[0];
	s.parentNode.insertBefore(wf, s);
})();

The demo files will all use this technique but I’ll keep it simple here and only show you relevant function for the technique in the following examples.

Now, moving to the next technique, we’re going to create a clipping-like effect on our canvas by changing the value of the globalcompositeOperation property of our context. The final result will look like the following:

The canvas context comes with the property globalcompositeOperation which defines the composite operations between what is known as the “source” and the “destination”. That is, it defines how what you want to draw will be blended with what is already drawn on the canvas. The source is what you want to draw, and the destination is what is already drawn before you set the globalCompositeOperation property. We can draw new elements or shapes behind existing shapes and mask off certain areas and even clear sections from the canvas using this property.

The globalCompositeOperation can take one of 16 values, each of these values is demonstrated clearly in a visual example on MDN, so check that out if you’re not familiar with this property yet, as those examples will help you understand the values we’re going to set next a lot better. Here’s a screenshot of the results of each of those values. In the demo’s source code, the destination is the blue rectangle which is drawn on the canvas first, and the source is the red circle which is drawn after the globalCompositeOperation value is set.

The source-in value of this property could be translated in plain English to “draw only the parts/areas of the source and destination where they intersect”. So, if you have two elements, one drawn and another one that you want to draw, the result will be that only the areas where these two elements intersect will be painted.

To help understand this better, let’s get into the code right away.

var canvas = document.getElementById("canvas");
var ctx = canvas.getContext("2d");

var img = document.createElement("img");
img.onload = function () {
   drawText();
}
img.src="img/fire.jpg";
function drawText() {
  
    // put text on canvas
    ctx.font = "bold 180pt IM Fell Great Primer SC";
    ctx.fillStyle = 'white';
    ctx.textAlign = 'center';
    var x = canvas.width / 2;
    ctx.fillText("FIRE", x, 325);

    // use compositing to draw the background image only where the text has been drawn
    ctx.globalCompositeOperation = "source-in";
    ctx.drawImage(img, 0, 0, img.width, img.height, 0, 0, canvas.width, canvas.height);
}

In the above code, inside the drawText function, we have 3 “sections” that define the result of what will be drawn on the canvas. The first section is where we define the text, including all its styles, and then we go ahead and draw it using the fillText method. Next, we set the globalCompositeOperation of our context to source-in. Then, we draw the image on the canvas.

So you see, the “source” in this case is the element that we want to draw after the globalCompositeOperation has been set (the image), and the “destination” is the text that we drew before we set it. And by setting the value to source-in, we’re telling the browser to draw the image only in the areas where this image intersects with the text, and that’s exactly how we get that clipping effect that we’re after.

Once you wrap your head around each of the values of the globalCompositeOperation, you can start using them quickly and with ease, and, again, do make sure you check the visual examples on MDN, because they help a lot.

When you do check them out, you’ll notice that if we set the value to source-atop, the result will be also the same for our demo. source-atop tells the browser to draw the parts/areas of the source (image) where it intersects with the destination (text), and also draw the remaining areas of the destination even those that do not intersect with the source, and in our case, that would also result in the same effect that we want.

View the live demo (demo for this technique.

Note: at the time of writing of this article, not all values of the global composite operation property are supported across browsers. There are six modes that work across browsers (in Chrome, Safari, Firefox, and Opera): source-over, source-atop, destination-over, destination-out, lighter, and xor. You can read more about this here. And for more advanced examples of using the global composite operation property, check out this post on HTML5Rocks to learn more about creating some really cool typographic effects with canvas.

And last but not least, we’re going to create one more effect using canvas, but this time we’ll be adding some texture to the text to blend it into the background like we did in the previous techniques with SVG and CSS. The demo will look like the following:

We’re going to be using an image with alpha channels as our “mask”, and we want the text to be drawn only where it intersects with the black areas of the image, and to be “erased” where the image is transparent, right? So we want our source and destination to only be painted where they intersect with each other. According to this logic, and to the above screenshot of the globalCompositeOperation values, we’ll want to use the source-in value to get the result we’re after.

Below is the image that we’re using as a “mask”. The black areas are where the image is going to intersect with the text. Just like we did in the CSS masking section, you can imagine one layer for the text and another for this image, put them on top of each other, and then erase any part of the image or text where the two don’t intersect with each other, and you get the final effect resulting from the source-in global composite operation.

The Javascript code is the same as the one above, only the value of the globalCompositeOperation is different, so we’ll jump right to the live demo, where you can check out the source code and play with it.

See the demo (demo 9) in action.

And here again we added a background to our canvas to make the blending effect a little more realistic. We have a “scratched” background with scratched text that blend with each other nicely.

Animating Text Backgrounds

Not only can text have a background, but you can actually animate this background and create some neat interactive effects with it. Because this article is focused on techniques for adding background/texture to text, we won’t be going over how to animate these backgrounds, because that could be a whole article on its own.

Mary Lou has written an article where she experimented with the CSS background-clip: text property, and created some neat text background effects, so make sure to check them out!

Trent Walton has also written an article where he goes over creating a text with a gradient background and animates that background resulting in a really nice and subtle effect.

And as always, Codepen includes some creative experiments using the CSS background-clip property with CSS animations, and among those I chose this really cool experiment by Lucas Bebber, in which he creates a nice effect of a text being filled with water, and provides a fallback for browsers that don’t support background-clip: text, so check that out as well and fiddle with the code, for there are some really cool techniques used to create the filling water effect.

Image Replacements

Because of the lack of browser support for a lot of the techniques used to create textured text effects, a lot of developers have been resorting to image replacement techniques to display graphical text.

There have been a lot of techniques available throughout the years, and Chris Coyier has done a great job collecting all of these techniques with their pros and cons in what he called the CSS Image Replacement Museum.

If you do not want to use any of the above techniques to create “graphical” text effects, and want to use one of the image replacement techniques available, you should also have a look at the newest of all techniques, a great technique by Scott Kellum, the one he called “The New Kellum Method”, in which he suggests using sort of an “empty” font, so to speak, which is a font which can be defined with the @font-face rule, and whose characters have no width and no marks, making the text invisible, and therefore allows you to avoid all the other techniques where you would need to hide the original text to make only the text’s background show.

There are a lot of articles out there that elaborate on these image replacement techniques, and because these techniques are outside the scope of this tutorial which is aimed at showing techniques to create graphical text without having to replace it with an image, I’m only going to list a few resources that I recommend reading if you want to know more about (or use) an image replacement:

• The CSS Image Replacement Museum on CSS-Tricks
• Replacing The -9999px Hack (The Kellum Method) by Jeffrey Zeldman
• Another CSS image replacement technique by Nicolas Gallagher
• The New Kellum Method by Scott Kellum

Final Words

I hope you learned a new technique or two from this article. I think we covered most of the possible ways to to create textured text with CSS and HTML. My favorite technique has to be the SVG one, simply because of its wider browser support. And when the day comes that all browsers support CSS masks and the background-clip‘s text value, we can start using them without having to worry too much about providing fallbacks anymore, and then CSS would definitely be the best choice for us.

I hope you found this article useful. Thank you for reading! =)

Do you know other techniques for adding textures to text? If you do, make sure you share them in the comments below!