Free Online Tutorials for Photoshop Autocad Rapidshare

free auto cad programs

2009-04-10T07:39:00.000-07:00

1) Quick screen-shot demonstration of how eMachineShop works:

Custom fabrication was never this streamlined, cost-effective, and enjoyable.

Download now and be designing in minutes!

2) SmartDraw 2009 Suite Edition is the easy drawing software that lets you create professional floor plans, facility diagrams, home designs, and more in minutes Looking for an easy, downloadable CAD program

3) Free DWG Viewer Publisher Description will open native DWG, DXF, and DWF files for viewing, along with accompanying Xref files. It will also open Informative Graphics' own "content sealed" (CSF) file format, which is generated by the company's Net-It publishing products and featuring Visual Rights security options for file content. The DWG viewer also supports IGC's legacy formats from previous versions of Brava! and MYRIAD. View native AutoCAD r12 to 2005 files. Download (13.9 MB)

Download Free Autocad viewer

2008-02-26T11:18:00.000-08:00

DWGgateway now reads AutoCAD 2007

If you’re an AutoCAD user who occasionally has issues sharing files with colleagues, DWGgateway can make your life easier than ever now that it reads files created with AutoCAD 2007.

Why use DWGgateway?
No need to upgrade to the next version of AutoCAD software

You do not have to upgrade your AutoCAD license to the new version of AutoCAD to be compatible with your DWG files.
Open and edit any DWG file using any version of AutoCAD

Eliminate the need to upgrade AutoCAD licenses just to be able to share work and collaborate with other AutoCAD users. DWGgateway is the first free data translation plug-in that lets AutoCAD users work easily with DWG files created by any version of AutoCAD software.

DWGgateway is simple

* Open DWG files created by any version of AutoCAD software.
* Save DWG files to any version of AutoCAD software.
* No need to leave the AutoCAD UI to open, save, or convert files - simply access DWGgateway from inside AutoCAD.
* Quick and easy download - the file size is small and there are no lengthy forms to fill out

Create industry standard PDF documents from within AutoCAD

DWGgateway enables AutoCAD users to create PDF documents that can be shared with virtually anyone. DWGgateway includes Adobe® PDF Library technology. Adobe PDF is the de facto standard for electronic document exchange. More than one half-billion copies of its companion software, Adobe® Reader®, have been distributed worldwide, and the world's top 10 PC makers ship their systems with the application.

What users are saying:

"An excellent option for those who do not want to be forced to constantly upgrade their AutoCAD. I have both opened and used several AutoCAD 2004 drawings on 2000i with no problems!."

Jeff Hamilton

Longwall Associates

How to search rapidshare on Google

2008-02-26T10:53:00.000-08:00

Get a free rapidshare premium account. Rapidshare is giving free rapidshare accounts regularly. Check whenever they are available and create a new one immediately. This tool will automatically checks for the premium accounts availablity. You dont need to go to rapidshare site and check for them. It will automatically checks and informs you. So download it now and get a free rapidshare premium account.
Get it here..

When it comes to finding the top entertainment on the internet, knowing how to search and use the various websites is crucial. One of the more popular entertainment-based websites on the internet is Rapidshare, which offers movies, software, mp3, music and much more. Here are a few tips on how to search Rapidshare through other websites.

When you begin searching Rapidshare through other sites, you will notice categories toward the top of the page. Within these categories you will find web, blog, groups, images and extensions. This makes it easy for you to quickly identify what you are looking for.

If you want to find blogs about music Rapidshare or TV Rapidshare, simple go to the blogs category. And the same goes for the other categories, allowing you to find the subject that you are looking for. This way you can quickly start searching for TV files or music files and forego having to search through all of the other entertainment pieces that are irrelevant to you.

On one website that promotes Rapidshare and Megaupload, there is a place where you can search either by the title or URL that you’re looking for. This way if you know the exact URL, you can type it in and quickly jump to the site you want. While most people aren’t familiar with the URL they’re looking for, knowing the title for the movie or TV show that you want to download can bring you to the file immediately.

When you search Rapidshare, there are a number of different files for all kinds of entertainment. Sites like sharing engines, which I mentioned above, allow you to find what you want without getting lost on the Rapidshare website. Aside from the categories and searching by title or URL, there is also a Google search bar on this website. This way you can type in a broad term if you’re not sure on the title or URL of what you’re looking for. This will bring up a plethora of results that you can scroll through to help you find what you’re looking for.

As the internet continues to evolve, more and more websites are developing rapidly. Because of this, it can sometimes be difficult to find what you’re looking for. Searching Rapidshare is not the easiest thing in the world to do because of the numerous files and categories given to you. However, with these tips you should be able to search Rapidshare, Megaupload and many sites comparable to it rather quickly.

100an drama ji rapidshare wang yi

2008-02-26T10:42:00.000-08:00

Taipei, Aug. 8 (CNA) Premier Chang Chun-hsiung said Wednesday the government will continue working to have fugitive Rebar Group founder Wang You-theng repatriated back to Taiwan through legal means, in the wake of Wang's release from a holding center in the United States.
All Olympic venues -- with the exception of the showpiece "Bird’s Nest" stadium -- would be finished by the end of the year and ticket sales were going well, said Wang Wei, executive vice president of the Beijing Organising Committee for the Olympic Games (BOCOG).

Wand Word Used for the Following items on rapidshare search
vera wang
vera wang wedding dress
wang
vera wang wedding gown
wang chung
wang lee hom
princess vera wang
vera wang perfume
sleepwear vera wang
kumpulan wang simpanan pekerja
vera wang wedding
vera wang dress
chien ming wang
100an drama ji turboupload wang yi
100an drama ji sendspace wang yi
100an drama ji megaupload wang yi
100an drama ji rapidshare wang yi
frank wank
vera wang bridal
wang center
wang theater
dress vera wang wedding womens
wang s
vera wang jewelry
cyndi wang
perfume princess vera wang
vera wang bridal gown
sandra wang
wang leehom
vera wang bridesmaid
vera wang gown
jiro wang
ji wang
vera wang shoes
vera wang bridesmaid dress
vera wang china
wang theater boston
alexander wang
vera wang bridal dress
wang center boston
wayne wang
lucky or wang
garrett wang
pink truly vera wang
wang wei
vera wang bridal collection
kumpulan wang simpanan pekerja malaysia
wang lee hom lyric
jimmy wang yang
sam wang
vera wang fragrance
nathan wang
vera wang maid
mattress vera wang
vera wang ring
vera wang for man
vera wang wedding invitation
label lavender vera wang
shanxing wang
vera wang invitation
ming the wang
wangyi
the death of woman wang
jian wang
vera wang bridal shoes
david wang
cindy wang
his wang
vera wang eye glasses
dr wang
wang zhizhi
jennifer saskatoon wang
vera wang handbag
vera wang wedding shoes
vera wang cologne
wang bu liu xing
vera wang purse
by princess vera wang
robert wang
vera wang earring
mattress serta vera wang
charles wang
wang center boston ma
k wang
wang yani
vera wang bridesmaid gown
wang theater boston ma
vera wang engagement ring
wang yu
wang computer
lisa wang
designer wang
vera wang prom dress
183 club sam wang
liqin wang
margaret wang
big wang
vera wang love knots
vera wang grosgrain
ase wang
Wang

Music Hero-Guitar Lesson Nine

2008-02-26T10:39:00.000-08:00

Let's take a look at the major and minor 3rd:


Major 3rd		Minor 3rd

Now let's look at how our harmonized scale lays out on the A and D-strings:

Seen this way, it is immediately obvious which harmonies are major (C-E, F-A, G-B) and which are minor (D-F, E-G, A-C, B-D).

Let's add this new information onto our staff:

If you look closely, you should see that the major and minor intervals form an easily recognizable pattern:

1st measure:	M3	m3	m3	M3
2nd measure:	M3	m3	m3	M3

If we look at the whole-steps and half-steps between each harmony, we will see that they are also the same in each measure:

1st measure:	M3		m3		m3		M3
		W		W		h
2nd measure:	M3		m3		m3		M3

That leaves only the whole-step between the two measures, so let's put that in:

Now, we know from working with the major scale in every key, that while each key has a different combination of notes, the intervals are exactly the same, no matter which note you start on. That means that you can use this exact same pattern of major and minor 3rds to harmonize the major scale in any key. All you have to do is play the correct order of the harmonies and follow the whole-step/half-step pattern of the scale.

So, the major scale, no matter what key you play it in, will always yield this exact same pattern of major and minor 3rds, and the harmonies will always follow the same W/h-step pattern. This fact allows us to assign a number to each of the harmonies, so that we can talk about them without regard to which key signature is being used:

iii

vii

In this case, Roman numerals are used instead of regular (Arabic) numbers. This is to distinguish between intervals (which are designated with Arabic numerals) and harmonies built from each note of the scale (which use Roman numerals). Notice that upper case numerals are used to designate major and lower case numerals are used to designate minor.

These Roman numerals are very important, because they are used to analyze and identify the chords within a chord progression. We'el talk some more about this in the next lesson. For now, just learn to call each harmony by the correct number, and memorize the pattern of major and minor, as well as where each type sits along the W/h-step pattern.

Now, before I set you to work playing this harmonized scale in every key and on every pair of strings (You knew that was coming, didn't you?), let me point out one more thing.

You know that the scale can be played up and down the entire length of the string. Once you reach the octave, you can just keep going higher through the scale until you run out of frets. You also know that you can play any notes from the scale that are below your starting note. This is also true for the harmonized scale. Notice that both the starting harmony and the ending harmony are considered I. This is because they are the same harmony. They're just an octave apart. Any notes that are an octave apart (higher or lower) are considered the same thing. This is because notes that are an octave apart function the same within a song.

So, once you reach I an octave higher, you can keep going into the next octave until you can't play any higher. The same thing is true for any scale tones that are below your root note. They can be harmonized too.

You need to practice the harmonized scale all the way up and down the strings, not just from I to I.

Also, when you are working with the G and B-strings, remember that the note on the B-string will be a fret higher than usual. This is always true when it comes to the B-string.

This is where I get to tell you what you should already know by now. You need to work this harmonized scale out in every key on every pair of strings and all the way up and down the neck.

Go for it!

Guitar Lesson Eight - Theory

2008-02-26T10:37:00.000-08:00

Part II:

I'm sure that you have noticed by now that I place a lot of importance on learning scales. The reason for this is that scales are the foundation for all music. Everything that you hear when listening to a piece of music is based on scales. Therefore, in order to have any sort of understanding of how music is constructed, you must have a firm understanding of scales.

At this point within the lessons, you need to have worked with both the major and minor scales enough that you can play both scales in all twelve keys on any string and be comfortable working with both scales on any two adjacent strings.

The first step in creating music from a scale is melody. All the work you have done with scales so far has been geared toward exploring the melodic possibilities of scales. Now we are going to begin exploring how scales create harmony. Harmony is created whenever two or more notes are played together. Chords are an example of complex harmony. We are going to look at simple harmony.

Harmonizing Scales:

Playing more than one note at a time (harmony) requires that you be able to see a scale on two strings at once.

We'll use the A major scale on the low E and A-strings for our example:

Now, familiarize yourself with the position of each interval on the A-string relative to the root at the 5th fret of the E-string:

With proper hand position, you should find every interval except the 7th and octave within reach of the root at the 5th fret on the E-string.

When playing harmony, each interval is given a designation. The 2nd, 3rd, 6th and 7th are called major intervals, while the 4th and 5th are called perfect intervals. This designation is important, because it is the basis of how chords are named. Also, if you play the A at the 5th fret of the E-string and the open A-string together the interval is called unison. Unison means that two notes of the same pitch are being played together.

Let's take a look at what each interval looks like in standard notation:

Hey!! There's a key signature for you to read!

Familiarize yourself with the sound and location of each interval. You will find that certain intervals sound pleasing to the ear while others sound tense or dissonant. For the sake of being able to hear the 7th and octave intervals, these notes can be moved over to the 6th and 7th fret of the D-string.

Now, we'll do the same thing with the A minor scale.

First, let's see how the scale lines up on both strings:

Now, familiarize yourself with each of the intervals relative to the root note at the fifth fret of the E-string:

Recall that the 3rd, 6th and 7th in there natural position are called major intervals. When you flat a major interval it becomes a minor interval. Minor intervals are usually denoted with a lower case "m" as opposed to a capital "M".

Here's the A minor scale intervals in standard notation:

Are you looking at the key signature? Do you understand how that key signature indicates A minor?

One of the cool things about the guitar is that except for the B-string, the tuning of the strings is uniform. What this means to you and me is that we can move everything over to the A and D-strings without having to learn new relationships between all of our intervals:

Notice that all of the intervals are in the same position relative to the root on the A-string. This will be true for every pair of strings except the G and B-strings. Remember that the B-string is tuned ½-step down from the rest of the strings. This means that all the intervals on the B-string will be one fret higher than you would normally expect.

Now, figure out the major and minor intervals on every pair of strings for all twelve keys. Once you get going with it, you'll find that it isn't hard to do at all.

Theory -Guitar Lesson Seven

2008-02-26T10:35:00.000-08:00

Theory Part I

The major scale and the minor scale have a unique relationship with each other. This is because the minor scale is actually built from the major scale. Each major scale has a minor scale inside of it.

Let's take a look at the major scale.

If you have worked through each of the preceding lessons, you know quite a bit about the major scale. You know that the note you start on is called the root note. You know that the rest of the notes follow a pattern of whole-steps and half-steps and that this scale produces the intervals 1 - 2 - 3 - 4 - 5 - 6 - 7- 8. You also know that the major scale can start on any note.

Now I'm going to add one more item to your knowledge of the major scale: the minor scale.

The minor scale is arrived at by starting and stopping on the 6th note of the major scale. For example, if we take the C major scale (C D E F G A B C) and start on the 6th note (A) instead of the original root (C), we get the A minor scale (A B C D E F G A). Notice that we are using the exact same notes as the C major scale, we only changed which note we start and stop on. This is very important. By starting and stopping on A, your ear will begin to hear that note as the root note. (It is important that you make sure that you are playing the correct notes. You may find yourself accidentally playing the notes of A major (A B C# D E F# G#), because that is what you are used to hearing. Pay close attention so that you are sure to play the correct notes.)

The minor scale may sound a bit odd to you at first. That's ok. It takes a little while to get used to a new scale sound. That is why I started you on the minor scale in the last lesson. You should be getting used to this new sound by now. This will make it a little easier for you to understand and work with the relationship between the major scale and the minor scale.

The C major scale and the A minor scale are considered RELATIVE to one another because they share the exact same notes. You could say that the two scales are like brother and sister.

C major scale:	C D E F G A B C
Relative minor:	A B C D E F G A

G major scale:	G A B C D E F# G
Relative minor:	E F# G A B C D E

D major scale:	D E F# G A B C# D
Relative minor:	B C# D E F# G A B
etc...

Now, once you have your chart finished, you need to practice the major scale and it's relative minor scale in each key. But don't try to practice them all at once. It's better if you take one scale per day and work that scale and it's relative minor scale up and down each string. The next day, pick a different key. Do this every day until you have practiced in every key. Over time you will begin to see the relationship between the two scales in every key.

Introduction-Guitar Lesson Six

2008-02-26T10:33:00.000-08:00

Introduction

So far, within these lessons, The majority of our focus has been geared toward approaching the guitar's six strings individually. That focus is now going to shift to working with two strings at a time.

At this point, you will begin to see Patterns and shapes emerging from the fretboard. These patterns and shapes are very important to the organization of musical ideas on the guitar, and, once you begin to see them, the fingerboard will open up for you.

This does not mean that you should stop practicing up and down each string individually.

Instead, what you may have to do is structure your practice time to include equal amounts of work in both areas. Eventually, you will find yourself able to seamlessly integrate both approaches.

Now, once we have explored the possibilities of two strings, we will look at three strings and then we will move on to POSITION playing.

Position playing is the direct opposite of playing up and down the strings. Instead of moving up and down the fingerboard, position playing requires you to play across the strings with little or no linear hand movement.

By the time we have covered position playing, you will have gained a most thorough understanding of the guitar fingerboard and will be able to move quite easily into any area of the fretboard that the music dictates.

This approach to learning the guitar seems the most logical to me, but you should not hesitate to take advantage of ANY resources that you happen across, even if they are not within the bounds of what I am currently showing you.

There is a lifetime of information that can be learned about playing the guitar. My goal is to give you the best tools that I know of to start you on your journey.

So, how does a person decide whether to play the notes on a single string or to use more than one string?

There are no rules for this. You have to decide for yourself.

Unless the music requires a technique, such as a slide, which can only be accomplished by staying on the same string, I will generally opt for the easiest way of playing the notes. There are enough difficult things that you will encounter without intentionally adding to their number.

How to play Guitar

2008-02-26T10:30:00.000-08:00

INTONATION. (There is a lot of debate that rages regarding this subject. It's a lot like the "which came first, the chicken or the egg?" debate.

Now, the overtones are mathematically proportional to the fundamental. What that means to you and me is that no two fundamentals produce the exact same overtones. In other words, if an instrument were built to play in the key of C, and the overtones were used to generate the pitches for the rest of the scale, that instrument would not be capable of playing in tune in any key other than C.

This is how instruments were built for centuries.

Eventually, the desire for MODULATION (changing key) within a piece of music became great enough that instrument builders began to experiment with what is called TEMPERED TUNINGS.

In order to have an understanding of temperment, one must first come to terms with the CIRCLE OF FIFTHS.

Let's say that we are playing in the key of C, and we want to modulate to another. The smoothest transition will be found if we move to a new key that is very similar to the key we are in. In other words, the fewer notes that we have to alter in our original scale to accommodate the new scale, the easier it will be to modulate to the new key.

Now, take a look at the scale chart that you constructed in lesson 4. You will notice that, in both the "scales with sharps" column and the "scales with flats" column, each scale has one more sharp or flat than the previous scale. Also, notice that within the "scales with sharps" column that each successive scale is built off of the 5th note of the preceding scale, and that within the "scales with flats" column that each successive scale is built of the 4th tone of the preceding scale.

What this implies, is that the smoothest modulation from our original key of C will be to the key of G or the key of F, because we would only have to change one note (F to F# or B to Bb) to accommodate the key change.

Let's say that we modulate to G. Once there, we might want to modulate to another new key. If we choose the 4th tone of G for our modulation, that would take us back to the key of C (study your scale chart if this is not clear). Therefore,the only option for modulating somewhere new, is to go to the 5th tone (D).

If we were to continue modulating to the fifth tone of each scale, we would eventually arrive back on our original key of C (I guess the world is round after all).

This successive modulation can be expressed in a circle:

The tuning that we use today is called EQUAL TEMPERMENT. Equal temperment is arrived at by tuning each 5th in the circle 2 cents flat (2 cents x 12 keys = 24 cents). This leaves us with a major chord that is sharp by 14 cents (we can live with that) on the 3rd note of the scale, and 2 cents flat (barely noticable) on the 5th note of the scale, but allows us to modulate into any key with equal ease.

All the other notes of the scale are also slightly out of tune with the overtones.

This presents a bit of a problem, especially when combined with the distortion channel (lead channel, overdrive channel etc...) found on most guitar amplifiers. This type of sound is generated by over-emphasising the harmonic overtones until a saturation level is reached.

What this all means, is that every time you play a note, you are also setting into motion a whole slew of overtones. If your trying to tune one note to another, your hearing, not only the fundamental that you are trying to tune, but also the harmonics involved with both notes.

This is one of the reasons for most tuning methods using unisons (exact same note) or octaves. These notes are the only ones that are supposed to be in tune within equal temperment. Unisons and octaves also share the same pitches within the overtone series.

Now, recall that in the tuning section of lesson 4, I detailed two tuning methods that use harmonics, one good and one bad. The method that I labeled as good uses unison and octave harmonics in conjunction with fretted and open-string notes. This will yeild very accurate tuning.

The meathod that I labeled "bad", on the other hand, will leave your guitar out of tune.

Let's take a closer look:

When you play the harmonic at the 5th fret of the low E-string, the resultant pitch is E''. The harmonic at the 7th fret of the A-string is also an E. So far so good? Not quite.

If you look at our circle of fifths, you'll see that E is the 5th of A. Equal temperment dictates that the 5th is tuned 2 cents flat, but you just tuned them pure.

Now, the frets on your guitar are spaced to give accurate equal tempered pitches, so, in essence, you have forced the A-string to play 2 cents flat, which is backward from what you need. ( A is supposed to be 2 cents flat from D not E. Study the circle if this is not clear.)

Keep in mind that 2 cents is not really enough to notice, but you're about to do the same thing, again, to the D-string. You're going to be left with a D-string that is 2 cents flat compared to the A-string which was already out of tune!

By the time you get to the high E-string, you will find that it is noticably out of tune when compared to the low E.

There are a few more things to consider about the effects of overtones on tuning:

ELECTRONIC TUNERS - When using an electronic tuner, and trying to tune using an open string, you're asking the tuner to pick out the fundamental from within a barrage of overtones. Is it any wonder that the dial goes crazy? If instead, you tune by playing the harmonic at the 12th fret into the tuner, you will provide the tuner with a more pure tone to read. Switching to the neck pickup on your guitar and/or rolling back on the tone knob will also help.

DISTORTION - Distortion (the sound of your amps lead channel) accentuates everything, especially tuning errors.

POWER CHORDS - Power chords are made up of a root note and a 5th (this is covered more fully in the theory part II section of this lesson). They sound great with lots of distortion, but we just learned that the 5th is supposed to be out of tune, and that distortion is going to accentuate the problem. It is sometimes necessary to tune your power chords pure and "deal" with the out-of-tuneness of the rest of the notes.

MAJOR CHORDS - Major chords use the 3rd note of the scale, which, in equal temperment, is pretty far out of tune. They sound pretty bad if you just hang out on them (one of the reasons that Country music can sound so "sour"). Again, distortion makes the problem even worse (one of the reasons that power chords are so common in Rock music).

DEAD STRINGS - When your strings begin to suffer from too much "wear and tear", they begin to vibrate inconsistently which produces odd harmonics. This makes it almost impossible to play in tune.

HARMONIC CONVERGENCE - If the "New-Agers" are right, the next time the planets line up we're all doomed. In that event, I don't suppose it will matter whether your guitar is in tune or not :-)

General Tips-Guitar Lesson Four

2008-02-26T10:27:00.000-08:00

General Tips

There are many different methods for tuning the guitar. We will cover the specifics of a few of the better methods in a moment, but first, let's look at some general guidlines that apply to any tuning method.

Reference pitch: All methods of tuning, except for the use of an electronic tuner, require that you have a reference pitch to tune at least one string to. There are many ways to get a reference pitch, such as:

Electronic tuner - Use the tuner to tune one string, and then, tune the rest of the strings by ear.
Another instrument - This could be a piano, keyboard, another guitar or any other instrument that playes pitches. You will, most probably, encounter this as you get out and play with other musicians.
Your own instrument - You can assume that at least one of the strings on your guitar is in tune, and tune the rest of the strings from there. Very rarely (unless you drop your guitar on the floor) will all of the strings on your guitar be out of tune at once. If you play a few familiar chords, you can usually determine that most of the strings are in tune and one or two are out. Once you determine which strings need to be tuned, you can tune them off of the strings that are in tune.
Tuning fork or pitchpipes - Tuning forks provide an extremely accurate reference whereas pitchpipes are practically worthless. You get what you pay for.
Off the record - When it comes to trying to play along with a recording, you will have to isolate a reference pitch from the recording itself. Often, it's easier to listen to the bass guitar to find a reference.
Misc. - I've heard of all manner of references being used, including the dial tone on the telephone. One guy that I read about in a magazine even tuned his guitar to the 60 cycle hum caused by electricity. (It has been determined by "those on high" that the A above middle C shall, henceforth, vibrate at none other than 440 Hz. 60 Hz, therefore, yields a pitch that is, roughly, halfway between B and Bb.)

5th fret: This is the most common "by-ear" meathod of tuning, due to the fact that it is the only method that utilizes the UNISON (two notes of the exact same pitch ringing together). Let's assume that your low E-string is in tune. Now, play the A note at the 5th fret of the E-string, and use that note to tune the A-string itself. The rest of the strings, except when tuning the B-string, are exactly the same. The 5th fret of the A tunes the D, the 5th fret of the D tunes the G, The 4th fret of the G tunes the B and the 5th fret of the B tunes the high E.

Octave: Tune the low E-string. Now tune the E at the 7th fret of the A-string to the open E-string. Then, tune the 7th fret of the D-string to the open A, the 7th fret of the G to the open D, The 8th fret of the B to the open G, and the 7th fret of the high E to the open B. I use this one to double check my tuning.

Harmonics (good): Tune the high E. Now tune the harmonic at the 12th fret of the B to the 7th fret of the high E, the 12th fret harmonic of the G to the 3rd fret of the high E, the 12th fret harmonic of the D to the 3rd fret of the B, the 12th fret harmonic of the A to the 2nd fret of the G, and the 12th fret harmonic of the low E to the 2nd fret of the D. This is the meathod I use to tune an acoustic guitar.

Harmonics (bad): You will inevitably run into a lot of people who use this one, so I'm going to lay it out for you, even though, it will leave your guitar out of tune. In the next lesson, I will provide you with a short discourse on harmonic overtones which will explain why this method is bad. So, why does everyone use this method? In a word, it's easy. Of all the tuning methods that I have ever seen, this one makes it the easiest to hear the beat. I suppose you could say that guitar players tend to be very lazy, so many of them choose ease over accuracy.

Here goes: Tune your low E. Then tune the harmonic at the 7th fret of the A to the harmonic at the 5th fret of the E. Tune the 7th fret harmonic of the D to the 5th fret harmonic of the A, and the 7th fret harmonic of the G to the 5th fret harmonic of the D. To tune the B, you have to use one of the other meathods like the 5th fret or octave. Once the B is in tune, tune the 7th fret harmonic of the high E to the 5th fret harmonic of the B.

Power chords: Power chords are second only to unisons and octaves for being the most "in tune" thing that you can play on the guitar. Start by tuning your low E. Then play some power chords using the E and A-strings up and down the neck, and tune the A-string so that it sounds right. Thats all there is to this one. Play power chords on all other pairs of strings, and just remember which string is in tune and which needs to be adjusted. Also, remember that the B-string is tuned a fret lower than the other strings. So, when you play a power chord using the G and B-strings, the notes have to be 3 frets apart instead of 2.

One final point: You don't have to start with one method and stick to that method only. I tend to "mix and match" from all the above methods (and a few more) on any given pair of strings, in order to really "nail" accurate tuning.

Tuning MIDI-Guitar Lesson Three

2008-02-26T10:24:00.000-08:00

THEORY

Although it might seem strange, (given the fact that the notes are named A through G) music theory centers around the key of C.

Below is the CHROMATIC SCALE starting with C:

C - C#/Db - D - D#/Eb - E - F - F#/Gb - G - G#/Ab - A - A#/Bb - B - C

A SCALE is nothing more than a clever way to travel from octave to octave. The word CHROMATIC comes from chroma or color. Think of the chromatic scale (because it contains every note) as one that includes all the colors.

Every other scale (there are hundreds of them) is constructed by selecting only certain notes from the chromatic scale.

The chromatic scale is the model used for the concept of WHOLE-STEPS and HALF-STEPS (sometimes refered to as WHOLE TONE and SEMITONE).

A HALF-STEP is the distance between any two notes along the chromatic scale. If you play any note of the chromatic scale and then play the next higher note OR the next lower note, that is considered a HALF-STEP.

A WHOLE-STEP is equal to the distance of two HALF-STEPS. Therefore, if you play any note of the chromatic scale and then play, not the next note, but, the note after that, you are executing a WHOLE-STEP. (C to C# is a half-step, C to D is a whole-step etc...)

When applied to the guitar, half-step translates to the distance of one fret and whole-step to the distance of two frets. It makes no difference what the names of the notes are. The only thing that matters, is how far apart those notes are. (Understand that B and C are one fret apart as are E and F. these two pair of notes are therefore a half-step and not a whole-step. This is a common misunderstanding that beginning students have when first learning this concept. They assume that because there is no sharp or flat between those notes that they are a whole-step apart.)

Now, before we continue, another definition:

A note that is neither sharp nor flat is considered NATURAL. The symbol used to denote NATURAL looks like this:

NATURAL is understood rather than written most of the time. In other words, unless you see a # or b attatched to a note, that note is assumed to be NATURAL and therefore, does not require the use of it's symbol. (When dealing with standard music notation however, you will encounter the NATURAL SIGN quite frequently.)

If you start on C and play only the NATURAL notes until you reach the octave, you will arrive at the notes of the C MAJOR SCALE:

C - D - E - F - G - A - B - C

(This is a good time to draw your attention to the word MAJOR. For reference sake music is divided into different catagories based on sound quality. Those things that are labeled MAJOR have a certain sound quality to them. This will be covered in great detail as we go along. For now, when you encounter such names as MAJOR, MINOR, DOMINANT, DIMINISHED or AUGMENTED don't worry about what they mean. This knowlege will come in time. All you need to understand at this point, is that these names refer to what I call FAMILIES OF SOUND.)

Now, if we look at the whole-steps and half-steps between each note of the C MAJOR SCALE, we find this pattern:

W - W - H - W - W - W - H

This pattern of whole-steps and half-steps is the single most important part of understanding music theory. Know it well.

Your theory assignment for this lesson is to map out the notes of the C major scale up and down each of the individual strings.

Here is what the high E-string looks like:

Notice the use of a Square on the eighth fret. This is a common visual aid for indicating the ROOT NOTE of a scale. ROOT NOTE means the note that the scale is based upon. Remember that we built our scale starting on C. Therefore, the ROOT NOTE of the scale is C and the sound of the scale is MAJOR.

When first learning a scale, It's important to start AND stop on the ROOT NOTE. This is so you learn to hear how all of the notes in the scale RESOLVE to the root.

Try this experiment.

Click on the MIDI file below and, while it's playing, do the following:

Play the root note several times. Notice that it sounds right at home.
Slowly, play the note above the root (D) twice, the note below the root (B) twice and then play the root and let the note ring. Notice that the D and B sound TENSE or unsettled and the C RESOLVES that TENSION.
Play the scale, slowly, from the C at the 8th fret up to the C at the 20th fret. (Be sure not to hit any wrong notes or you won't hear what I'm getting at) Notice how all the notes you play seem to naturally lead to the C at the 20th fret.
Slowly, play the scale back down to the C at the 8th fret. Again the notes seem to lead to the C.
Play the scale up to the 20th fret, again but, this time, pause on the B at the 19th fret for a moment. Then play the C at the 20th fret. Notice how "unfinished" the scale sounds when you pause on the B and how "complete" the scale sounds when you finally play the C.
Play the scale back down to the B at the 7th fret and pause for a moment. Then play the C. Again notice how "unfinished" it sounds when you pause on the B. This is called TENSION. Notice how "complete" it sounds when you finally play the C. This is called RESOLUTION.
From this experiment, you should realize how important TENSION and RESOLUTION are to creating music.

Now, go ahead and figure out the C major scale on the remaining strings. Don't worry about going across the strings (like you're doing with your finger exercises). Just play up and down the strings one at a time.

Once you have a fair idea of where the notes are on one string, play the MIDI file and practice going up and down the entire length of the fingerboard while listening to the sound that you are creating (If you ever sang do, re, mi, fa, so, la, ti, do in grade school, you're now playing the same thing on your guitar).

Then, go on to the next string.

Playing up and down the scale is good practice but, it's not really making music. Let's make some music!

Below is a MIDI of a CHORD PROGRESSION in the key of C major.

Pick a string and, play along with the file using the C major scale. Don't just play up and down the scale. Instead, try jumping around to different spots in the scale and see if you can come up with anything that sounds interesting.

Now, it's inevitable that you are going to hit some wrong notes. Don't worry about it. If you lose your place too badly just stop for a second and start over.

Also, If you can hear that you are hitting wrong notes, it's a good indication that you are developing an ear for what the scale is "supposed" to sound like.
You're not going to sound like Eddie Van Halen right away but, as a teacher I once had used to say, "All of the masters were born shitting in a diaper, just like you. The only thing that separates you from them is practice." Have fun, be adventurous and play like you mean it!

Bass-Guitar Lesson Two

2008-02-26T10:21:00.000-08:00

Begin by tuning your guitar using your electronic tuner. Check for accuracy by comparing the pitch of each string to tunning.mid

Theory

It's very important to know what notes you are playing at any given time. With practice, you will eventually reach a point where you can identify any note on any string at a glance. This may seem like a mammoth undertaking but, it is a lot easier than it may first appear.

The notes on the fingerboard are laid out in a very logical and consistent manner with only one exception. This exception is the B-string.

We will look at this inconsistency in greater detail in a moment. But first, let me show you something about the fingerboard.

In lesson one, we discussed how the notes are named and practiced playing up and down one string at a time while naming the notes. We also learned the term OCTAVE.

If you put these two pieces of information together, you will find that if you start on a given pitch and play up the string until you reach the OCTAVE, you will be exactly 12 frets higher than where you started. This means that 12 frets above any note on any string is a note with the same name ( It's important, at this point to make a distinction between NOTE and PITCH. NOTE refers strictly to the name of a given PITCH. If you play A, for example, and then play A an OCTAVE higher or lower, you are playing the same NOTE [ it has the same name] Even though, "technically", you are playing two different PITCHES.). The fact that the two notes have the same NAME and that the ear can have trouble distinguishing the difference in PITCH makes these two notes interchangeable. To a certain extent, If you are required to play a given note, it makes little difference which OCTAVE you play.

Now, take a look at the fingerboard on your guitar. You will notice that the 12th fret is clearly marked with two "fret dots" ( "Fret dots" is slang for the position markers that are inlaid into the wood of the fingerboard and along the edge of the neck at the 3rd, 5th, 7th, 9th, 12th, 15th, 17th, 19th, and 21st fret.) The 12th is the only fret that is given the distinction of two dots (On guitars that have 24 frets, the 24th fret will also have two dots.).

The distinct marking of the 12th fret provides us with an important visual reference point. This is the point at which the notes on the fingerboard begin to repeat.

Recall that the open strings are tuned E, A, D, G, B, E, low to high. If you follow the above statements, you should now see that the notes at the 12th fret are also E, A, D, G, B, E.

This means that you don't have to learn separate information to apply above the 12th fret. Anything you learn below the 12th fret will simply repeat itself above. This is true for chords, scales, licks, patterns and anything else you could imagine.

The above information can also make it easier to identify the notes below the 12th fret. Let's say that you want to find F on the A-string. One method is to start with the open A and make your way up the fingerboard until you arrive at F (a distance of 8 frets!). If instead, you were to start at the 12th fret and work your way down the string, you will find the note much faster (5 frets).

Now, let's say that you are playing the note at the 10th fret on the B-string and I ask you to tell me the name of the note you are playing. It should be obvious that the note you are playing is much closer to the 12th fret than it is to the open string. Therefore, it is an easy task to start at the 12th fret and work down the neck to the 10th fret and identify the note

Here are two more tools that will help you get the notes down:

The first should be painfully obvious. The highest and the lowest string are both tuned to E. This means that the notes are laid out exactly the same on both strings. At any given fret, you will find the same note on either of the two E-strings.

The second is a powerful tool for learning to see the notes across the fingerboard as opposed to up and down a single string.

In the diagram below, I have placed a square on the C note at the 8th fret of the Low E-string (It is common practice to refer to the two E-strings as Low E and High E). I have also placed a square on the OCTAVE C on the D-string:

From this diagram we can see that the octave of C at the 8th fret of the low E is two strings over (towards the floor) and two frets up (towards the 12th fret).

Watch what happens if we start with C at the 3rd fret of the A-string:

Again, we see the same pattern - two strings over, two frets up.

Now understand, we could have used any note we wanted to and this relationship would be the same. I just picked C for the hell of it.

Now lets take a look at the B-string.

The strings of the guitar are tuned in such a way that if you play the note at the 5th fret of any string (except the G-string) you will get the same note (and PITCH) as the next OPEN string. For example, if you play the note at the 5th fret of the low E-string you are playing A which of course is the note of the open A-string. If you play the note at the 5th fret of the A-string you get D. If you play the 5th fret of the D-string you get G.

But, if you play the 5th fret of the G-string you get C instead of B. To get the B note you have to play the 4th fret instead. Yet, if you play the 5th fret of the B-string you DO get E, but because the B-string is "funny" it makes the E-string "funny" as well.

What this means, for now, is that whenever the octave lands on the B-string or the E-string, It will be one fret higher ( the B-string is tuned one fret lower than all the strings before it and, since the E-string is tuned off of the B-string, the E-string is one fret lower as well).

Observe what happens if we plot the octave of the C at the 10th fret of the D-string as well as, the C at the 5th fret of the G-string:

This tuning discrepancy is necessary for playing chords. If you were to tune the B and E-strings up one fret so that they match the rest of the strings, all of the chords that you learned in the last lesson would be very hard to play.

Now, all you have to remember is 2 strings over, two frets up except when the octave falls on the B-string or the E-string where you get 2 strings over and 3 frets up.

Your assignment is to locate and memorize every C note on the guitar below and above the 12th fret. Use the tools I have given you and don't be afraid to cue off of the fret dots. That's why they're on the neck in the first place!

Tuning up-Guitar Lesson One

2008-02-26T10:17:00.000-08:00

Tuning up

The most difficult task that a beginning guitarist faces is tuning the instrument. As it takes time to develop a sense of pitch, I recommend that you use an electronic tuner at first. If you don't have one, go get one. It is impossible to learn to play on an out of tune guitar. You can pick up an electronic tuner for as little as $19.95, and it will pay for itself before the end of this first lesson. Make sure that the sales person shows you how to use it, and pay attention to what they tell you. If the instructions don't make sense to you, DO NOT leave the store until you understand EXACTLY how to use the tuner. If the sales person acts like they have something better to do than educate you on how to tune the guitar, leave a complaint with the management and go buy a tuner somewhere else. Playing in tune is THAT important!

Begin by tuning your guitar using your electronic tuner. Check for accuracy by comparing the pitch of each string to tunning.mid

As you work on this lesson, try tuning to the MIDI file by ear and then double checking for accuracy with your electronic tuner.

This lesson is divided into four parts:

Theory

Notes are named after the first seven letters in the alphabet. In order, they are:

A - B - C - D - E - F - G

Between any two notes, except B - C and E - F, we also have a sharp and/or flat note.

These are the symbols that are used to denote sharp and flat:

	= sharp
	= flat

If we list the notes, again, and include the sharps and flats, we get:

A - A#/Bb - B - C - C#/Db - D - D#/Eb - E - F - F#/Gb - G - G#/Ab - A

One important thing to notice is that X#/Xb is one note that has two names (The term used to describe this is ENHARMONIC). For example, A# is the exact same note as Bb. Sometimes, one name will be used, and sometimes the other name will be used. We will cover this in much greater detail in a later lesson. For now, it's only important that you know the names of the notes.

Another thing to notice is that after G#/Ab We arrive at A again. This second A vibrates exactly twice as fast as the first A, and therefore, the ear tends to hear it as another version of the same note. The second A is called the OCTAVE of the first A. If we continue after the second A, we get A#/Bb an OCTAVE higher than the first, B an OCTAVE higher, C an OCTAVE higher etc., etc., until we get to A again. This A is two OCTAVES higher than the first A. If we keep going, the whole pattern just repeats over and over until we can't get any higher on the instrument. (If you didn't run out of notes, you could keep right on going until the notes were so high that only a dog could hear them!) The same is true if you travel in the opposite direction. The pattern repeats until you run out of notes, or the neighbors call the cops (whichever comes first).

Here's something to help you remember the sharps and flats. If you sharpen a pencil, you raise a point on it. Therefore, if you play A and then play the next higher note, you would call the second note A#. If you flatten a pop can, you mash it down. Likewise, if you play B and then play the next lower note, you would call the second note Bb. Remember that A# and Bb are the exact same note or ENHARMONIC.

This may be a bit confusing but, you'el get used to it.

All you have to remember is A through G of the alphabet and a #/b note in between every two notes except B - C and E - F (there's no such note as B# or Cb, likewise, E# or Fb. There is an exception to this but, that's way down the road!).

Now, the strings of the guitar are tuned E A D G B E from the lowest sounding to the highest sounding.

What I have for you, is an exercise that uses the A-string to practice playing and naming the notes. Don't worry about the standard music notation right now. Just follow the TAB until you get the idea. Once you get the idea of the exercise, don't use the TAB either. You have to know this stuff by heart.

The idea of this exercise is to start on the OPEN (if you just play the string without putting any finger down on it, its called OPEN) A-string and play each note, in order, up and down the string, while naming the note out loud to yourself. Don't worry about which left-hand fingers to use. Just use whatever seems comfortable. We'el start worrying about which fingers to use later.

It looks like this:

I only took the exercise up to the 12th fret but, you could keep going as high up the neck as possible before heading back down to the OPEN string. (Up and down directions on guitar ALWAYS refer to the pitch of the notes. If you go up the neck, you go from playing lower sounding notes to higher sounding notes. If you go down the neck, you go from playing higher sounding notes to lower sounding notes.)

Once you can go up and down the A-string and name the notes (Don't worry about trying to remember exactly where each note is. That will come later. Just get the pattern of how the notes are named so that you know it by heart.), do the same thing on the other strings.

If you start on the D-string (or any other string), the pattern is still the same. You're just starting in a different spot:

D - D# - E - F - F# - G - G# - A - A# - B - C - C# - D

I left out the flats because I'm tired of typing them, but they're still there, just like before.

Isometric Triangular Dot Paper printable

2008-02-26T10:07:00.000-08:00

Isometric Triangular Dot Paper

Asymmetric graph paper is typically used for knitting patterns. Knit stitches are taller than they are wide. You can set your own width to height ratio here to accomodate the type of stitch used.

Brick graph paper is typically used for beadwork patterns, but it has other applications as well. You can set your own width to height ratio. Useful for smocking designs.

Variable aspect ratios, and optional description lines. If you need paper to plan out your broadcast or film production,

The monster of log paper generators. Full log, or semi log on either axis. Up to 6 cycles per axis for printing very large format sheets.

Arbitrary start and end numbers. Integer or non-integer increments. (By non-integer, I still mean reals... things like 0.5 and 0.2 seem to be nice... incrementing by "0.82 + 62i" would be a problem.)

Cornell Lined

Cornell Lined Note Taking System. One page divided into 3 sections, with a bunch of lines in one of them.

Cornell Music

Standard Cornell Graph Paper layout with places to jot down your compositions and other musical notes.

3D ISOMETRIC DRAWING

2008-02-26T09:46:00.000-08:00

SUMMATIVE TASK - 3D ISOMETRIC DRAWING

Using a computer and CAD Qickdraw drawing software, produce a rendered/surfaced isometric drawing of the orthogonal projection of the LOCKING JIG drawn below. Scale 1:1. No dimensions required.

Class work - formative (CAD)

Using a computer and CAD Qickdraw drawing software, produce a rendered/surfaced isometric drawing of the orthogonal projections drawn below. Scale 1:1. No dimensions required.

SUMMATIVE TASK � ESSAY (homework)

TASK

In the early 1980s, CAD, along with other technologies made their way into the traditional drafting industry, and, as a consequence these have changed the way outcomes are produced.

The essay needs to be structured in such a way that it has an introduction, body, conclusion and a bibliography as main headings.

INTRODUCTION

A number of well-structured sentences stating specifically what topics and points that the essay is going to cover.

BODY

What is traditional drafting?

What is CAD drafting?

What is CADD?

Compare the two drafting methods giving both good and bad points of each.

What technologies have made their way into the drafting industry and how are outcomes produced?

CONCLUSION

Personal thoughts and opinions, giving reasons that support your views on the topic.

BIBLIOGRAPHY

List of references indicating research and reading used to obtain information to help compile the essay.

ASSESSMENT SCHEME

Your essay needs to be in your own words, double line spaced, minimum of 250 word-processed words, with a 25-millimetre margin.

SUMMATIVE TASK 2 - 2D ORTHOGONAL PROJECTION

Using a computer, 2D CAD Qickdraw drawing soft ware, set up a 5 x 5 grid and produce orthogonal projections in third angle (TOP VIEW, FRONT VIEW and RIGHT SIDE VIEW) of the isometric drawing of the SHAFT BRACKET drawn below. Drawing is to be drawn to a scale of 1 : 1 (full size) and be fully dimensioned.

Homework assignments - formative

Using a rule and a red biro, complete the orthogonal projections in the 5 x 5 grids provided. Count the grid square on the isometric drawing opposite to obtain the necessary measurements for the completion of the orthogonal projections.

Add any missing hidden edge lines and out lines to complete the orthogonal projection.

Class work - formative (CAD)

Using a computer, 2D CAD Qickdraw drawing soft ware, set up a 5 x 5 grid and produce orthogonal projections in third angle (TOP VIEW, FRONT VIEW and RIGHT SIDE VIEW) of the following drawn isometric drawings. Drawings are to be drawn to a scale of 1 : 1 (full size) and be fully dimensioned.

NB. Produces a free hand pencil sketch of the three views and have them checked before using a computer.

NB. Work out the view spacing for each exercise.

NB. All line styles are to be of the correct thickness (value).

NB. Have your CAD drawing checked off as you you complete each drawing exercise.

ASSESSMENT SCHEME

Accuracy of TOP VIEW /10

Accuracy of FRONT VIEW /10

Accuracy of RIGHT SIDE VIEW /10

Correct line values / view spacing / names of views /10

TOTAL /40

Homework assignments - formative

Add any missing hidden edge lines and out lines to complete the orthogonal projection.

ASK 1 - 2D ORTHOGONAL PROJECTION without DIMENSIONS

Class work 'a' - formative (CAD)

Using a computer, 2D CAD Qickdraw drawing soft ware, work through the procedure with accompanying dimensioned drawing and accurately reproduce the following drawn objects. Use a scale of 1 : 1 (full size).

Architectural Desktop

2008-02-24T11:46:00.000-08:00

The essential tools in ADT Schedule 2006 enable instant one-click scheduling and bill of materials, plus dynamic spreadsheet linking between Architectural Desktop or Building Systems and Microsoft Excel.

ADT Schedule provides the fastest and most effective way to generate schedules and bill of materials - all at the click of a button! Its feature-rich toolset lets you query drawings for Architectural Desktop objects and block attribute data and save it to a variety of file formats.

Keep your Microsoft Excel spreadsheets synchronized with the Dynamic Link option. Simply edit the current workbook and your drawing updates automatically! Alternatively, you can work on spreadsheets remotely and update associated drawings in an instant with the unique import options.

Key Features:

One-click scheduling of selected objects in the current drawing or multiple drawings containing Xrefs!

Rule Manager lets you merge tabled items based on user-defined criteria.

Set spreadsheet styles with unique Excel formatting options.

Query drawings for object data and save it to a variety of file formats including Microsoft Excel, Access, CSV and XML.

Hot-link Architectural Desktop drawings with Excel spreadsheets.

Dynamically update objects and blocks for true design synchronization!

Modify the standard physical properties of objects and blocks from within Excel.

Connect 'live' to spreadsheets or import from spreadsheet file.

Dynamic Link feature supports Microsoft Excel 97, 2000 and XP.

ADT Schedule supports Architectural Desktop 2000-2006 and Building Systems. The software can be installed on a standalone computer or network drive (you can connect the entire design team with total network support options). Further details are available during installation.

Name:

GcadAs2006Trial.exe

Date:

14/01/2006

Size:

7.51 MB

Version:

1.2

Author:

sales@globalcad.com

Website:

http://www.globalcad.com

Cost:

30 day trial (£195.00)

Downloads:

797

Rating:

10/10 (1 Votes)

Operating Systems: ADT 2000
ADT 2000i
ADT 2002
ADT 2004
ADT 2005
ADT 2006
Building Systems

Connection	Download Time
56k Modem	22 mins, 76 secs
128k ISDN	9 mins, 63 secs
256k Cable/DSL	4 mins, 64 secs
512k Cable/DSL	2 mins, 41 secs
1mbit Link	1 mins, 19 secs

What are the main poblems in SolidWorks

2008-02-24T11:34:00.000-08:00

Why does Solidworks allow you to change the gear ratio?

Free Solidworks tutorials download

Disable Auto convert

What are all the Icons in SolidWorks

Can someone give me the quick and dirty on solidworks!?

Circular Pattern problems

How to cut internal annular grooves

Need help with cosmos

Drawings

Would SW be best for my work type ?

Changing dimensions on Toolbox parts

dealing with balloons

compressing a Solidworks file

Introducing SolidWorks 2008

SolidWorks Office Premium

IGES file question

Fastener threads....

make model into solid

Problem with Sheet Metal Bends

How to avert this disaster

basic question

Multiple bodies to single feature

Solidworks models in my AutoCAD drawings?

Solidworks vs Autocad

Solidworks to CAD

SolidWorks World 2008

SolidWorks installation, missing Toolbox

Solidworks training books and demo CD’s in the book stores??

Solidworks Training Center

catia sketcher tutorials

SolidWorks file extensions

Crazy Lips Games

2008-02-24T11:16:00.000-08:00

Kindly Use your keyboard and turened up the sound to enjoy this amazing fun that you may never seen before on internet

Crazy Mobile Fun

MP3 Sharing Community

2008-02-24T11:12:00.000-08:00

There was a time were Little Ponies ran free all over the world and Google didn’t actually meant anything yet (Long live HotBot.com). Back in those days of the Y2K fever and before the RIAA rule the world (and killed all the little ponies) I designed a logo (a mascot) and website for a MP3 Sharing Community. Ahhh… to be young and reckless.

Eventually the site was taken down voluntarily, so the new redesign never saw the light. Until now.

I can already see tons of traffic coming from search engines looking for the last Britney single. So, If you got here because you typed “mp3 britney download” I’m sorry this is just a piece of work I’ve done in the past for a MP3 Sharing Community that is NO LONGER AVAILABLE. I don’t know Britney and I have parted ways with the frog (not before he stole my headphones) long time ago. Actually, I heard he’s dating Britney now, so go away and let me mourn alone in the dark

NOS Logo, Website, Accounting and Sales

2008-02-24T11:06:00.001-08:00

Yes, that is true. NOS is the company I founded with my partner Martin Acuña. NOS is the reason I’m a partner at SUM Agency today and the reason I’m here now. What else can I say. NOS represents the first time I wake up one day and thought to myself “Hey… I can do this for a living”. The very next thing I did that morning was to call my boss at the time to let him know I was quiting. Actually, I think I got dressed and then I called my boss. Mmm… no I’m pretty sure I quited while I was still in my undies.

But it’s true. The first years we did everything from going after the client, working on the RFP’s, answering the phone, even standing in line for hours to make a deposit.

Anyway before I get emotional, let’s talk about the actual work. First, the name. I wasn’t sure about what I wanted for my company’s name, but I was dead sure about what I didn’t wanted. I didn’t wanted to be seen as a huge, impersonal, design agency. I also didn’t wanted to fall into cliches like having super hip and cool words on the brand like ventures, technologies, solutions, interactive, etc. Plus, we were only a bunch of guys. We couldn’t even fool our families. We were just us. us in Spanish translates to Nosotros and that’s how we originally named ourselves.

Then in 2006 we wanted to enter the US Market and Nosotros was a bit to hard to pronounce so we shortened to NOS which even in Spanish, still holds its meaning. Of course, the brand needed to reflect our versatility (hence the multicolor logo) and the fact that we were a small, united agency. By playing with the kerning on the NOS we achieve that concept.

Our first website had this photo I took by the bay in Asuncion on a Sunday afternoon right before a huge storm. The camera moves down slowly and you would see us sitting on two benches. Quite simply really. Maybe that’s why so many people liked it.

By 2006 we switched from Flash to a XHTML/CSS design and this time, we offered an ~~english~~ someglish version, as well as a German version of our site.

The website also featured a bunch of photos to resemblance the colors of our logo.

SUM Agency Logo and Website

2008-02-24T11:03:00.000-08:00

In October of 2006 SUM Agency was founded with the solely idea of providing creative solutions that help our clients succeed and obtain their goals. This is by far the most fun I have ever been while actually working.

Our website received very good feedback from media and it was featured on several design galleries and websites, including #1 position for The Smashing Magazine’s 11 Almost Perfect Business Layouts and most recently being picked to appear in the upcoming Design Meltdown Book.

This is a our Reel section on the SUM Agency website.

Inheriting the same concept from NOS, we chose a colored pattern to communicate the versatility of the company.

Web Design: From Good to Great in 25 Links

2008-02-24T10:59:00.000-08:00

Web Design: From Good to Great in 25 Links
Unless you’ve been living under a very large rock, you probably know this is that time of the year were everyone feels obligated to provide advice about what’s good, what’s not and what’s just plain stupid.

So lately I've been debating with myself about whether or not I should write an article about Web Design Advice and Tips, mainly because:

I think there's one too many "Super Ultimate Definitive Guide to XYZ" already, plus I don't have a super ultimate definitive knowledge on anything, (well except for matching socks, I sure know how to pick'em) and...
You know what they say about advice being just a form of nostalgia, so the last thing I would've wanted is to sound like a war veteran

Then yesterday, while catching up with my RSS feeds, I found a great (and sadly true) post from Greg about how hard is it to find good talent in today's industry.

As an employer of a growing number of full-time and freelance workers I can tell you that it's becoming increasingly difficult to find good people. I have had several conversations with persons of top stature in the web design business who are of the same opinion. Their own businesses' have been slightly crippled this year due to work demand vs. human supply.

I don't see there being a quick turn-around for this problem but it will escalate if we don't spend time and resources to proactively help improve the situation

After reading Greg's post (and experience it several times myself), I decided to help, to be more proactive and write an useful list of resources that could simplify what I learned over the last 11 years in Web Design. Who knows, that old Spanish Proverb might be right after all:

The Devil is wiser because he's old, not because he's the Devil

"iStockphoto is the world's preeminent collection of member-generated royalty-free images, at the world's best prices. There are no subscription fees or extra costs. Just the best Stock Photography, Vector illustrations, Flash Files, and Videos, at prices for everyone"

Visit the site

Smashing Magazine's

11 Almost Perfect Business Layout

"Business companies tend to impress visitors with solid site structures, precise navigation and the credibility of presented content. Therefore business layouts are usually quite unspectacular, mostly informative, but not attractive.

Yay for SUM Agency appearing #1 on the list!

Visit the site

While this probably not the Ultimate and Definitive way to do it, If you go through each and one of them, you WILL take your talent to a different level.

Enjoy and good luck!

Free Seo Tools

2008-02-24T10:55:00.000-08:00

free search submission

seo references

Ajax Resources

2008-02-24T10:51:00.000-08:00

Ajax Resources

Miscellaneous tools

2008-02-24T10:47:00.000-08:00

Miscellaneous tools

Top Quality Photoshopped Images

2008-02-24T10:27:00.000-08:00

Sometimes they can be funny, sometimes thought provoking, other times they just mess with your mind. They’ll always take your breath away though and make you wonder at the skills of the people that created them. The following images are our favorite Photoshopped images. If you’ve seen better we’d love to hear from you.

How To Use Rapidshare

2008-02-24T10:23:00.000-08:00

A quick and painless step by step that explains how Rapidshare works and how to quickly download files from Rapidshare links.

Begin by simply click the link or by copying the link into your web browser.

Scroll down to the bottom of the page.

Press the FREE button to start the download.

Upon click the FREE button, a second, similar page will load.

Scroll down to the bottom of the second page.

Find the download counter; you must wait until the counter finishes before the download will begin.

After waiting for the counter to finish or by using the trick, a third page will appear.

Scroll down to the bottom of the third page.

The file name will appear with a code to begin the download. Copy the code exactly how it is provided and click the link to begin the download. This will prompt the user to save the file.

Real Time Pixel Manipulation in VB5

2008-01-28T12:25:00.000-08:00

Real Time Pixel Manipulation in VB5

Introduction

The article "Speed up your apps with pointer" by Matthew Curland and Francesco Balena in the October VBPJ has big implications for image processing in VB.

I had always used C for anything dealing with pointers and pixels, it's just not something you do in VB. Not only was VB slower than C, but the terrible VB pixel twins Point and Pset made image processing unbearable.

But no longer - VB5 is now comparable to the speed of C in many areas, and thanks to Safe Arrays we can access the memory directly.

What its good for

What can you do with all this new found power? Well this technique is useful anytime you want to update an image from incoming data, or from a mathematical transformation of an existing image.

Some example of how you can use it include

Real time Graphs : displaying data like sound, frequency, voltage or processor usage
Image Processing : brightness, contrast, edge detect, invert, shadows
Effects : melt, fade, ripple, bump map
Real time 3D : Texture mapped polygons (Wolfenstien/Doom), Heightfield maps

I have included many samples of these over the last few months, including some C examples to further exploit this technique.

I will cover the first two types of pixel manipulation in this article in some detail.

Real Time Graphs

This technique is ideal for drawing graphs of 2D data. You simply plot your points to scale along the vertical and horizontal axis.

To illustrate this with an example we will build a signal generator. For those of you familiar with electronics, a signal generator and an oscilloscope can provide hours of fun. (That's sarcasm for those of you who are unfamiliar with Kiwi humour)

Simply graph time along the x axis and the result of the sinusoidal (SIN) function on the Y axis. By adding offsets and scaling factors we can modify the shape and frequency of the wave.

This particular diagram shows a sinusoidal wave, but the framework applies to any function, including data you may sample from a real input (like steam pressure or stock market trading).

The amplitude is simply used to scale the function so it is easy to examine. The DC-offset so that the function is nicely centred in the graph window. The frequency is the rate of sampling, how often you update or sample your data.

You can take the Safe Array framework provided and simply insert your custom function.

How do we draw the graph?

In this case we first set every pixel to black to wipe the last frame. Then we step horizontally through the image. The vertical position of each pixel is then calculated using the DC offset, the amplitude, and the frequency from our "scroll bars". The wave will be updated and displayed in real time.

This routine uses 8 Bit graphics. This means each pixel is represented by one byte, or 256 possible colors. This is also called a palletized image, this is because from all possible 24 bit colors a palette of only 256 are made available. The advantage of 8 bit graphics is speed, because you have to copy only byte per pixel.

For c = 0 To UBound(pict, 1)
   'make this column black
   For r = 0 To UBound(pict, 2)
       pict(c, r) = 0
   Next

   'now find the row of the sin wave
   'Stick your function in here!!
   sin_row% = Int(Sin(GetTickCount() / 1000 + c / freq!) * amp%) + dc%

   'make sure the wave is not too big
   If sin_row% <0> 140 Then sin_row% = 140

   'now draw the wave using three pixels to make it appear smoother
   pict(c, sin_row%) = 14 'dark green
   pict(c, sin_row% + 1) = 23 'light green
   pict(c, sin_row% + 2) = 14 'dark green
Next

The finished 'VB signal generator'

Image Processing

In contrast most image processing is best performed on 24 bit images. Although they are 3 times bigger than 8 bit images, each pixel can represent any color - rather than being restricted by a palette.

The first byte holds Red (0-255), the second Green (0-255), and the third Blue (0-255). 0 represents an absence of the color - while a value of 255 is fully saturated. Therefore Black is R=0 G=0 B=0 while White is R=255 G=255 B=255. This leads me to my first example of image processing, brightness.

Brightness

Brightness is really the simplest possible example of image processing, scale each byte up for a lighter image, or down for a darker image.

 NewPixel = OldPixel * Brightness

Brightness is a logarithmic scale. This means that from 0 up to 1 the image will get darker. From 1 onwards the image will get lighter.

Because we have to perform this scaling operation 3 times for every pixel (for each the red, blue and green bytes), it is important it is very fast. The problem with the technique described above is that 3 times every pixel we need to convert a byte to a floating point, do a floating point multiplication, fix up overflow (values > 255) and then convert a floating point back to a byte.

 t! = pict2(c, r) * brightness!
 If t! > 255 Then t! = 255
 pict(c, r) = t!

However, because each byte has only 255 possible values, we can pre-calculate a 255 byte lookup table.

For example, this creates a lookup table;

 For a% = 0 to 255
  Temp! = a% * brightness!
  If temp! > 255 then temp! = 255
  table_bright(a%) = temp!
 next

Now the core routine is simplified to 1 line;

 Pict(c,r) = table_bright(pict2(c,r))

This optimization much faster. My rule of thumb for image processing is to get it looking ok in the VB IDE, and then it should look great when it's compiled!

Blur

Blurring an image can come in handy when you want to resize it. The normal Windows StretchBlt routine uses point sampling to resize an image. This means when you make an image smaller it just picks a pixel (point) from the source image to represent a group of pixels in the destination image.

This is a slightly contrived example, but it shows how the regular point sampling can include a shape like 'A' while missing a shape like 'B' alltogether. The Triangles are mis-represented, as 'C' becomes 2 horizontal dots, while 'D' becomes 3 vertical dots.

The problem with this is that the image gets all sorts of weird sampling errors, particularly noticeable when the image has fine regular shapes (like text). Blurring can provide a solution to this problem, before you point sample, blur the source image. This results in the point being an average of the surrounding samples (known as resampling).

The blur algorithm I am using is very simple. Just move through the pixels, averaging the current pixel, the pixel above it, below it, left of it and to it's right.

  For c = 3 To UBound(pict, 1) - 3
           For r = 1 To UBound(pict, 2) - 1
               pict(c, r) = (CInt(pict2(c, r)) + _
   CInt(pict2(c - 3, r)) +_
   CInt(pict2(c + 3, r)) +_
   CInt(pict2(c, r - 1)) +_
   CInt(pict2(c, r + 1))) \ 5
           Next
 Next

Remember the Column is offset by 3 because it takes 3 bytes to make a pixel, we blur the R, G and B components separately.

There are a variety of other image processing samples provided including contrast, ripple and the ability to adjust RGB brightness individually. Have a look at the sample program.

Optimization Tips

For real time image processing consider using 8 bit images for higher speed.
Optimize your inner loop by pre-calculating values and using lookup tables.
Consider using C for more demanding image processing. I have provided tutorials that make it very easy to create a C DLL you can call from VB.
Experiment

Source and exe's ~40k

Cheers
David Brebner

david@ur.co.nz

DirectDraw for Visual Basic®

2008-01-28T12:22:00.000-08:00

DirectDraw for Visual Basic^®

Introduction

This text is about the DirectDraw system for VB. DirectDraw is comprised of 10 classes. Each of these classes abstracts an important aspect for video / graphics programming. This text does not cover all of the classes, but is limited to the following:

DirectDraw7
DirectDrawClipper
DirectDrawEnumModes
DirectDrawPalette
DirectDrawSurface7

These five classes form the foundation for using DirectDraw as a tool for games and animation. The rest of the classes will be covered in later DirectX-files™.

We will start this file with a small overview of each of the classes that will be covered in this text. An in-depth discussion of each class will be given as the DirectX-file™ series progresses.

DirectDraw7

This is the main DirectDraw object. This object is used to create a few of the other objects, but also to provide generic system info on the video hardware capabilities and the DirectDraw driver version installed on the system. The DirectDraw7 object is used in the setup phase of a program to set certain system settings and properties and to get information about the available resources and possible configurations.

DirectDrawClipper

This object is used to automate clipping functionality. Giving the control of clipping to the DirectDrawClipper can mean the difference between a fast program and a really fast program. A clipper is basically a list of RECTS (rectangular structures) that determine the areas where the bit block transfer (The Blitter) can move pixels to (Blit to).

DirectDrawEnumModes

This object is used to store the possible display mode settings of the system. It is a very simple object and will be introduced in the first sample application.

DirectDrawPalette

The object encapsulates the palette used on the DirectDraw surfaces. It functionality and purpose is the same as the normal Win32 palette. Palettes in DirectDraw are still widely used and we will examine some pretty funky palette animation tricks.

DirectDrawSurface7

This is the most used and most important in the collection of objects that DirectDraw is. It holds function and methods for blitting, accessing, storing and using video memory either with assisted hardware or in pure software. The surface is such an essential object in DirectDraw that you must be careful that you completely understand it and how it is used. Through this object we can get direct access to the memory of the video card, which is something completely unique in the world of Win32 so please read the sections on the surface carefully.

Sub case 1: Setting up DirectDraw

Purpose

The purpose of this sub case is to demonstrate using the DirectDraw7 object. We will examine how to use this object to get information on the possible settings for the display mode supported by your hardware and also see how we can set these. Likewise will present the 'standard' way of creating the top DirectDraw objects.

Pay special attention to the details surrounding the setting of the display mode and cooperation level.

Getting into it

The project presented is the DXFile1_1 sample project. As stated above, this project has a twofold purpose – first we will obtain the possible display resolution configurations of the primary display card, and then try out these settings by changing the display mode.

The first step before doing anything else with DirectDraw is to declare and initialize the main DirectDraw and DirectX objects. These main objects are essential for any DirectDraw application. It is these we will use to create and initialize the rest of the DirectDraw objects. Since the DirectX7 object and the DirectDraw7 objects are being used in this context we must keep them active throughout the lifetime of the application, and only release them when we terminate the application. In this example we have declared the objects and given them global scope by placing them in the General Declarations section of the main form. The declarations are shown in Listing 1:

Option Explicit
       
        Dim objDx As DirectX7
        Dim objDraw7 As DirectDraw7
        Dim objEnumModes As DirectDrawEnumModes

Listing 1 shows the declarations for the DXFile1_1 sample project

The DirectX7 object is the main DirectX object. It is from this object that we will create the DirectDraw object (this object is also used to create the other foundation objects of DirectX, such as DirectSound, Direct3D etc.). The DirectX7 object also contains some useful generic methods, which can be considered global methods for the DirectX libraries. These include, among others, functionality for setting an event callback function, getting the RECT of the main DirectDraw window, getting system color information (usable by both Direct3D and DirectDraw). In this sample we will only be concerned with the method for creating a DirectDraw7 object.

The DirectDraw7 object is in essence a representation of a video card installed on the system. Since both Windows98 and Windows2000 supports multiple video cards you can have multiple DirectDraw7 objects. This file will not cover multiple video card support.

Using the DirectDraw7 object you can instantiate the other related object that make up the DirectDraw object. You can also use it to get information on the available features of the video card / driver and the state of the video card and video memory. All objects created from the DirectDraw7 objects are destroyed and unusable if the DirectDraw7 object is destroyed. Therefore it is of utmost importance that you control both the scope and the lifetime of this object. As we progress into the DirectX-file™ series we will study the methods and features of this object in considerably more detail. For now, just remember that it is this object that is used to create other DirectDraw related objects. When it gets released, so will all the other objects we created using it.

As you can see from Listing 1 we have declared a third object with Public scope. This object is a DirectDrawEnumModes object. This object will, when we create and initialize it, contain all the possible display settings of the video card. It is a simple object with only two methods, GetCount and GetItem. We will be covering these in just a short while.

Starting the Engine

The main object creation and initialization action takes place in the load event of our form. The first thing we have to do is to create a new DirectX object. This is done in much the same way as you create any new object in Visual Basic – using the New operator. If this creation fails you will get a run-time error indicating the failure. There is always the possibility that the user of your application has not installed the version of DirectX that your program requires. It is therefore essential that you trap any errors and warn the user if your program requires a later version than what has been installed. We will trap any errors in the declared ErrHandler label.

After creating a valid DirectX7 object we can use it to create the DirectDraw7 object via the DirectDrawCreate function.

In the sample application we simply create the DirectDraw7 object by passing an empty string. After having created the DirectDraw7 object we use the GetDisplayModesEnum function for getting the available display modes into the DirectDrawEnumModes object. This object will then contain all the possible display modes that we can use in our application. You should always check the display hardware to see if it supports a given resolution. Otherwise, if you try to set a resolution that the hardware does not support you will get a run-time error.

The DirectDrawEnumModes has two methods – GetCount and GetItem. The GetCount method returns the number of available display settings as a simple long. We'll use this function to get the upper bounds of the iterative that fills the list box. As you might have guessed we use the GetItem method to retrieve the settings available. This method takes two parameters, the first being the index to the item that should be received. This index must be in the range of 1 – GetCount(), if it is not a run-time error is generated. The second parameter is a DDSURFACEDESC2 structure. This structure is a descriptor for a given surface and is used it many contexts. In this application we use the lWidth, lHeight and the ddpfPixelFormat.lRGBBitCount members to retrieve the Height, Width and Color depth of the primary surface. In the initialization phase of the sample application we put these members in a list box for display.

The code for initializing the application is shown in Listing 2.

Private Sub Form_Load()
       
        On Error GoTo ErrHandler:
       
        Dim ddsd As DDSURFACEDESC2
        Dim I As Long, lgCount As Long
       
        Set objDx = New DirectX7
        ''Create DirectDraw object
        Set objDraw7 = objDx.DirectDrawCreate("")
       
        ''Get the modes in the enum modes object
        Set objEnumModes = objDraw7.GetDisplayModesEnum(DDEDM_DEFAULT, ddsd)
       
        ''Put the data in the listbox
        lgCount = objEnumModes.GetCount()
       
        For I = 1 To lgCount
       
    objEnumModes.GetItem I, ddsd
       
    lstDisplayModes.AddItem CStr(ddsd.lWidth) & "x" & CStr(ddsd.lHeight) & "x" _
        & CStr(ddsd.ddpfPixelFormat.lRGBBitCount)
        Next I
       
        ErrHandler:
       
    Select Case Err.Number
       
        Case 0 ''No Errors
       
        Case Else
        Err.Raise Err.Number, Err.Source, Err.Description, Err.HelpContext,  Err.HelpContext
       
            Call CleanUp
       
    End Select
       
        End Sub

Listing 2 shows the initialization for the DXFile1_1 sample project

One more thing that is worth mentioning is the Error handling in the initialization phase of the application. It cannot be stressed enough how important this is. You must catch any run-time errors that are thrown. If you do not, you run the risk of your application bombing. First and foremost, your application will stop executing before it really starts – and you are not likely to sell many games that way. It may also be possible that the error can be 'fixed'. By trapping and addressing the error, we can keep our program running. A future DirectX-file™ will deal exclusively with error handling techniques that you can employ. Just remember you must do it, even though it seems like redundant and boring code, otherwise you will surely pay the price.

After initialization, the application is ready to run. You should be seeing a small window with a list box and two command buttons, something like Figure 1:

Try to select an item in the list box and click the ‘Set Selected Display mode’ button. Suddenly your display mode will change and the small window will be resized to fill the entire desktop. You have just done two things. First, you have changed the Display setting, and second, you have acquired the entire display under your control. If you move the window around a bit you can see other windows behind it (if you have any open), but you still have control of everything on the primary display. Don’t mistake your form for the primary display – they are two very distinct entities (as we will see later).

The code that changes and acquires the control over the display is in the SetNewDisplayMode function shown in Listing 3:

Private Function SetNewDisplayMode()
        On Error GoTo ErrHandler
       
        Dim ddsd As DDSURFACEDESC2
        Dim I As Long
       
    ''Get the selected item
    I = lstDisplayModes.ListIndex
    If I = -1 Then
        MsgBox "Please select item in Listbox", vbOKOnly, "Error"
        Exit Function
    End If
       
    objEnumModes.GetItem (I + 1), ddsd
       
    ''Set cooperative level
    objDraw7.SetCooperativeLevel Me.hWnd, DDSCL_FULLSCREEN Or DDSCL_ALLOWMODEX Or  _ DDSCL_EXCLUSIVE
       
    ''Set the display mode
    objDraw7.SetDisplayMode ddsd.lWidth, ddsd.lHeight, ddsd.ddpfPixelFormat.lRGBBitCount, 0,  _ DDSDM_DEFAULT
       
    ''Draw the form
    Me.Refresh
       
        ErrHandler:
       
    Select Case Err.Number
       
        Case 0 ''No Errors
       
        Case Else
       
            Err.Raise Err.Number, Err.Source, Err.Description, Err.HelpContext, Err.HelpContext
            Call CleanUp
       
    End Select
       
        End Function

Listing 3 shows the SetNewDisplayMode function in the DXFile1_1 sample project

The function first tries to identify the selected item from the List box. If no item has been selected, the user will be notified and the function will terminate; otherwise, the information for the selected item is stored in a DDSURFACEDESC2 structure. Before we can change the display setting of the primary display to match the selected information, we must announce how we want to cooperate with the DirectDraw system. This is done via the SetDisplayMode method of the DirectDraw7 object. The SetDisplayMode method is one of DirectDraw's initializing functions. This method tells the DirectDraw system how the application wants to interact with the rest of the system. At the basic level you have two choices on how your application can interact with the rest of the windows system: it can either take full and exclusive control of the display, or it can work as a normal window with no special rights. In this sample, we have taken full control of the display system and video card. This is the easiest approach since we do not have to worry about other running applications and their interaction with the system. Later, in this DirectX-file™ series, we will examine how to make DirectDraw applications that interact normally with Windows.

Lastly, we call a refresh on the form to make it display properly. Play around with the system for a while and enjoy the ‘fun’.

Afterthoughts

This sample is very simple and does not involve any special techniques or methods for accomplishing what we need. But it does serve as an example on how much of the interaction with the DirectDraw system is accomplished.

In the next sub case, we will examine some of DirectDraw's basic graphical abilities.

[DirectDraw 1-1] [DirectDraw 1-2]

Download Sample 1-1

The BitBlt API

2008-01-28T12:20:00.000-08:00

The BitBlt API
Author : Michael Lambino
Created : 11 May, 1998
Modified : 17 October, 1998
Skill Level : Beginner - Casual

This tutorial is a revised version of the original BitBlt API primer/tutorial I originally wrote in May, 1998. Most of the content remains the same, it's just that I've (hopefully) made it a little easier to read. You can also download the associated demo project here.

It appears that want of information for this popular API never seems to cease. The BitBlt API call was the first API I learned how to implement, as I suspect may be the case with many who may come across this tutorial. It is for this reason why the tutorial is geared mainly towards newbies but hopefully there's something in it for everybody.

If you read and re-read parts of this tutorial and find that parts are a little over your head, skip the paragraph and try out the code. Come back to it in your own time (days, weeks, months) and things will get clearer. Like most things dealing with programming, practice makes perfect. There are improvements that can be applied to the method of bltting that I show here, let me make that perfectly clear :o), so treat this material as a starting point and then write some code, and then write some more.

One thing not to forget though is to Enjoy :o) -- Catch you all later!

So, what is this BitBlt I've been hearing so much about?

BitBlt is an acronym for Bit Block Transfer. It is an API function exposed by the GDI32.dll that performs a transfer of a rectangular area of an image to another rectangular area of equal size. This includes copying, combining or merging images and displaying the result.

An important point to keep in mind is like most API calls, Visual Basic knows not when you invoke the function. If you use the BitBlt function to perform a bltting operation to an object with it's AutoRedraw property set to True, you must call the object's Refresh method to update the screen with the image in memory... But more about this later.

Enough talk, show me the code!

The following listing (Listing 1.1) is the source code for a reusable .bas module that provides enumerated Raster Operation constants and the declaration for the BitBlt API function. A member of the enumerated raster operation type is used in the last parameter of a BitBlt function call.

The Bitblt API is a function exposed by the GDI32.dll, which is made available for use within your Visual Basic projects with the below (or similar) declaration. It is declared below to be used in a .bas module, in a global scope, making it accessable to all forms and modules you may be using in your project. You use the function as you would any other custom function you write in Visual Basic.

Listing 1.1 BitBlt.bas - Generic BitBlt API Declaration and Constants for use in a .bas module.

                     ' * * * * * * *          * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *          * * * * * * * * * * * * * * * * * * * * *       
                     ' Project
                   ' Filename
                   ' Description
                   ' Created
                   ' Modified                 :
                   :
                   :
                   :
                   :                 BitBltPrimer.vbp
                   BitBlt.bas
                   BitBlt API primer tutorial project
                   11.15 PM GMT + 10.00, February 23, 1998
                   12:26 AM GMT + 10.00, October 17, 1998       
                     ' * * * * * * *          * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *          * * * * * * * * * * * * * * * * * * * * *       
                     ' Author
                   ' E-mail
                   ' Comments
                   ' License
                   '
                   '                 :
                   :
                   :
                   :                 Michael          Lambino
                   ProSoft@the18th.com
                   Copyright  ©, 23 February, 1998 - Michael Lambino
                   Freeware - Freely distributable unmodified.  No costs may be          charged whatsoever for the distribution of this tutorial, in          any form of media, without expressed permission from the          author.       
                     ' * * * * * * *          * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *          * * * * * * * * * * * * * * * * * * * * *       
 

' Require all variables be declared. 
   Option Explicit

' Enumerated raster operation constants
   Public Enum RasterOps
       ' Copies the source bitmap to destination bitmap
        SRCCOPY = &HCC0020
       '
       ' Combines pixels of the destination with source bitmap using the Boolean AND operator.
        SRCAND = &H8800C6
       '                               
       ' Combines pixels of the destination with source bitmap using the Boolean XOR operator.
        SRCINVERT = &H660046   
       '
       ' Combines pixels of the destination with source bitmap using the Boolean OR operator.
        SRCPAINT = &HEE0086   
       '
       ' Inverts the destination bitmap and then combines the results with the source bitmap
       ' using the Boolean AND operator.
        SRCERASE = &H4400328   
       '
       ' Turns all output white.
        WHITENESS = &HFF0062
       '
       ' Turn output black.
        BLACKNESS = &H42 
   End Enum
 
' BitBlt API Public Declaration
    Declare Function BitBlt Lib "gdi32" ( _
       ByVal hDestDC As Long, _
       ByVal x As Long, _
       ByVal y As Long, _
       ByVal nWidth As Long, _
       ByVal nHeight As Long, _
       ByVal hSrcDC As Long, _
       ByVal xSrc As Long, _
       ByVal ySrc As Long, _
       ByVal dwRop As RasterOps _
       ) As Long

.. so, what does it all mean?

For now, skip the enumerated constants (that's the code between Public Enum RasterOps and End Enum), and we'll focus on the actual BitBlt Declaration, which, for the purpose of this tutorial we'll call the BitBlt function. Lets take a look at the parameters of the function and delve into them a little deeper than the more sane members of our communities ever would - Take a look at Listing 1.2

Listing 1.2 BitBlt.bas - A snippet of the BitBlt API declaration

ByVal hDestDC As Long, _
..
ByVal hSrcDC As Long, _

The values you pass here are the Destination Object's hDC (hence hDestDC) and the Source Object's hDC (hSrcDC). In saying that BitBlt transfers an image from one area of memory to another, the operating system needs to know where to find the image to transfer and where to send them too. Both the Source image and Destination object need to have a handle for Windows to find where the source pixels are and where the pixels should be painted too at any given time. This is where the hDC comes into play.

In the accompanying project, we use a PictureBox Object to contain the source image and use another PictureBox to contain the resulting image which is transferred, both of which support the hDC property. The hDC property of an object returns the handle in which your OS can find a device context ... huh? I hear you say ... In times of huh? we first turn to traditional resources of information (start with the VB Help file) -- it states that:

Borrowed from MS VB5 Help File

this property is a Windows operating environment device context handle. The Windows operating environment manages the system display by assigning a device context for ..... each form and PictureBox control in your application. You can use the hDC property to refer to the handle for an object's device context. This provides a value to pass to Windows API calls.

This API function needs to know where in the system memory the source pixels which you want transferred are located (as well as the destination you want them transferred too). You cannot simply say BitBlt PictureBox2 (Destination) from PictureBox1 (Source) and expect windows to understand or find what you've just asked it to. Instead we pass the handle to the Device Context, by calling BitBlt PictureBox2.hDC from PictureBox2.hDC .. nothing really hard! ;o) in fact, windows does all the hard work behind the scenes for you .. it actually creates a link between your application, a device driver, and an output device; such as the screen or a printer.

Now one more thing about hDC before we move on to the next parameters ... We've established that the hDC property provides a method of finding the location of an object in memory ... well another relevant question which you should ask yourself is -- Does the value that the hDC property return remain the same, and if so, for how long? -- well I'm glad you asked. In short, the answer is NO - the hDC may not remain the same during the lifetime of a running application. As the VB Help File suggests (lookup: hDC Property), do not hardcode the value returned by the hDC property in any API calls ... simply refer to the property whenever you need it. Experiment with this though as caching the hDC property can sometimes improve performance.

Whilst we're talking about memory and fun stuff like that, I might take a short timeout to look into the AutoRedraw property of an object. I said above that BitBlt transfers image data from a rectangular source image to a destination picture-container. When the AutoRedraw property of an object is set to True, then the system stores an image, contained by the object, in memory (persistant bitmap). Whilst this property is set to True, any changes done to the image will only be done to the image held in memory, NOT the image you see on the screen. When the AutoRedraw property of a destination object is set to true you must tell the OS to Refresh the on-screen image and update it with the image being held in memory. You do this by calling the Refresh method of the destination object (PictureBox2.Refresh).

Ok, I can hear someone saying, why bother - what's the advantage of that? Well an answer could be that theoretically, if you do all your changes to an image "off-screen" and then simply display the image when changes are completed, this will cause less "flicker" as opposed to displaying an image as changes are taking place. You can theorize, it is faster not to update the screen as you do the changes, as your application needs to pass thru a display driver which in turn instructs your monitor to update the changes, as opposed to doing all the work behind the scenes (in memory) and updating the screen once. This will definately be faster! Now, an important thing to remember is that you must use this technique wisely as memory is not infinate ... I'm sure I don't have to go into this :o) ...

Now, that's the end of one of the hardest concepts of this API call and a little background into the AutoRedraw property. As a reward here's a quick lookup table of all the parameters of the function. Don't bother copying and pasting the table as it comes in the BitBlt.bas module with the accompanying project download.

Listing 1.3 BitBlt.bas - Quick lookup table for the parameters of the BitBlt API Declaration

`' * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ' Parameter descriptions ' * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *`
`'`	`ByVal hDestDC As Long`	:	`hDC of object (Destination PictureBox hDC) in which resulting Blt` `operation will performed.`
`'`	`ByVal x As Long`	:	`Leftmost coordinate (upper-left) of the destination rectangle.`
`'`	`ByVal y As Long`	:	`Topmost coordinate (upper-left) of the destination rectangle.`
`'`	`ByVal nWidth As Long`	:	`width of the rectangle of the destination image to be bltted.`
`'`	`ByVal nHeight As Long`	:	`height of the rectangle of the destination image to be bltted.`
`'`	`ByVal hSrcDC As Long`	:	`hDC of object (Source PictureBox hDC) in which resulting Blt operation will be` `performed from.`
`'`	`ByVal xSrc As Long`	:	`Leftmost coordinate (upper-left) of the source rectangle.`
`'`	`ByVal ySrc As Long`	:	`Topmost coordinate (upper-left) of the source rectangle.`
`'`	`ByVal dwRop As Long`	:	`specifies the raster operation to be performed as above.`

Let's push on to the following parameters -- x, and y: Listing 1.4 BitBlt.bas

Listing 1.4 BitBlt.bas - A snippet of the BitBlt API declaration

ByVal x As Long, _
..
ByVal y As Long, _

The BitBlt API as stated numerous times above, transfers a rectangular portion of a source image onto a destination ... the X and Y parameters allow you to specify the exact whereabouts, on the destination, the rectangular source image should be transferred to. Just like positioning an object within a container (eg, a picturebox within a form), x and y are very similar to the object's .left and .top properties -- easy ;o) .. but wait for it!

x sets the distance between the internal left edge of the destination object and the leftmost coordinate at which the source image will be transferred, and
y sets the distance between the internal top edge of an destination object and the topmost coordinate at which the source image will be transferred.

There's really only one thing to bear in mind when passing values to the x, and y parameters of the function call. The unit of measurement used in setting x, and y, is PIXELS. This is different to the top and left properties of an object as they can use twips or any other user-defined unit of measurement.

X and Y allows you great control in the positioning of the transferred image. You can use the X and Y values to create tiled background effects or illusions of animation - but BitBlt doesn't stop there. It also allows you to specify whereabouts it should start transferring pixels from the source image. Take a look at :

Listing 1.5 BitBlt.bas - A snippet of the BitBlt API declaration

ByVal xSrc As Long, _
..
ByVal ySrc As Long, _

The BitBlt API allows you to specify whereabouts from a source image to start transferring pixels. This allows you to keep a number of different images (Sprites or tiles) in one image file (usually a grid of many images) and specify which sprite to transfer. As you can imagine, by keeping many frames or a sequence of images (used in animation) in one image file; this will allow for faster animation (as the system doesn't have to go through the process of accessing them from the harddrive) usually producing smoother animation. But with all good things come the bad - always keep in mind that the single (large) image may be held in memory.

Values for the xSrc and ySrc parameters are passed in the same way as x and y, as stated above.

xSrc sets the distance between the internal left edge of the source container and the leftmost coordinate you want to start tranferring the source image, and
ySrc sets the distance between the internal top edge of the source container and the topmost coordinate you want to start transferring the source image.

Also remember that xSrc and ySrc are measured in PIXELS!!

Now, the next two parameters of the function that we should look at is nWidth and nHeight. Take a look at the following :

Listing 1.6 BitBlt.bas - A snippet of the BitBlt API declaration

ByVal nWidth As Long, _
..
ByVal nHeight As Long, _

As said many times earlier, BitBlt transfers a rectangular source image to a destination. The height and width of the rectangle is set with these two parameters. The values that you pass to these parameters should be measured in pixels, again ;o) ... As you may now have figured out, pixels is the unit of measurement used with BitBlt, and generally speaking the unit of measurement used in API functions. To play it safe, set your source and destination object's ScaleMode properties to 3 - Pixels, but often this may end up confusing (or not possible) and may not be desired. A common question is how do I convert a value measured in twips to it's value measured in pixels? ... Maybe we should once again, take a timeout and look at the Screen object and it's properties!

In the last paragraph, I stated that it may not be possible to change the ScaleMode property of an object -- I was refering to the Screen object. Consider this - say you wanted to copy a portion of the desktop image and apply some cool affects to it using BitBlt -- for example, you wanted to grab the portion of the desktop's image (specifically; the area around a form in a project you are running) and paint it to your current form to make it appear transparent (see Source Code examples) or better yet apply some animation so it looks like it explodes!! }:o) -- you cannot use the form's .top and .left properties alone (to findout it's dynamic position) as their values are returned measured in twips! .... You must convert their values to pixels to attain the desired result.

The Screen object has properties that can be used to convert values measured in twips to their equivalent pixel value. The two properties in question are Screen.TwipsPerPixelX and Screen.TwipsPerPixelY. These properties return the number of Twips that can fit into one pixel horizontally and vertically, respectively, taking into account the current resolution. To convert a value measured in twips into pixels - divide the twips value by the value returned by Screen.TwipsPerPixel_ or to convert a value measured in pixels to twips simply multiply that value by TwipsPerPixel_ . Here's an example of converting a form's Leftmost coordinate from twips to pixel using integer division:

Dim lngLeft As Long

LngLeft = Form1.Left \ Screen.TwipsPerPixelsX

Ok! -- You should be able to know how to define a rectangular portion of a source image and know whereabout's on a destination object you want it transferred (whether you're using Twips or Pixels as the ScaleMode). Further, you should be able to understand how to let the Operating System know where to find both the source and destination objects!

Throughout this tutorial so far I've said that BitBlt transfers pixels from a source image to a destination. BitBlt allows you to transfer those pixels to your destination in a number of different ways. You have control over this by choosing which Raster Operation should be applied when transfer (or merging the source image with existing images in the destination) and this is done by passing a value into the last parameter in the function. Take a look at the following parameter :

Listing 1.7 BitBlt.bas - A snippet of the BitBlt API declaration

ByVal dwRop As RasterOps _

The first thing to take for granted here is that the information that is stored in a pixel (the colour of it) is stored as a numerical value (let's not get too technical to start off here). The BitBlt operation under Windows is not limited to a simple copying of an image to a destination, it also allows you to perform mathematical and logical operations on a source image and it's destination. The effects you can create (transparency, inverted colours) can be calculated if you understand the Raster Operations that are supported by BitBlt. But in understanding the raster operations it is a good idea to understand what OR, AND, NOT and XOR operations do to binary data. Before going any further into RasterOps, maybe a short lesson / recap in Boolean Algebra!??

Boolean what!?!

Boolean Algebra ;o) - Some background in it's uses may be in order first of all! -- It's pretty much common knowledge that computers, in it's most basic form, used to / still run on information transfered in Binary Language ... When you think of this mechanically we talk of switches ... The most basic switch has two states, On and Off, this in Binary language this is 1 and 0. Some machines which use this logic to perform tasks, can perform a wide number of operations - some of which may be as simple as: if a user hits either the Escape key (a Switch) or the F10 key (another Switch) perform the Quitting sequence ... In VB this is written like this :

Dim bEscapeKey As Boolean Dim bF10Key As Boolean		'Esc Key Flag 'F10 Key Flag
If bEscapeKey = True OR bF10Key = True then
	'Either Esc key or F10 key was depressed Unload Object
End If

Linking it back to boolean algebra this translates as the following :

bEscapeKey + bF10Key = Result (either 0 or 1)

The above boolean expression has the following possibilities (expressed using binary values) :

bEscapeKey	+	bF10Key	=	Result
0	+	0	=	0	(Do not run sequence as No key was depressed)
1	+	0	=	1	(Run Quit sequence as ESC Key was depressed)
0	+	1	=	1	(Run Quit sequence as F10 Key was depressed)
1	+	1	=	1	(Run Quit sequence as Both Keys were depressed)
.... as you can see the plus symbol is a little misleading and that's why OR is often used in it's place

That was just an example of the OR operator -- it speaks for itself really ... if Switch1 OR Switch2 is True then the Result will be True.

Another commonly used operation in boolean algebra is the AND operation. This operation also speaks for itself. Take the following scenario for instance ... if the CTRL Key AND the ALT Key AND the DELETE Key is pressed at the same time Quit! -- In Visual Basic this is written like this :


dim bCtrlKey As Boolean     'CTRL Key Flag
dim bAltKey As Boolean      'ALT Key Flag
dim bDelKey As Boolean      'DELETE Key Flag
 
     if bCtrlKey = True AND _
        bAltKey = True  AND _
        bDelKey = True then
          'CTRL & ALT & DEL keys were depressed
          unload object
     end if

Linking it back to boolean algebra this translates as the following :

bCtrlKey . bAltKey . bDelKey = Result (either 0 or 1)

The above boolean expression has the following possibilities (expressed using binary values) :

bCtrlKey	.	bAltKey	.	bDelKey	=	Result
0	.	0	.	0	=	0	(Do not run sequence as No key was depressed)
1	.	0	.	0	=	0	(Do not run Quit sequence as only one key was depressed)
0	.	1	.	0	=	0
0	.	0	.	1	=	0
1	.	1	.	0	=	0	(Do not run Quit sequence as only two Keys were depressed)
1	.	0	.	1	=	0
0	.	1	.	1	=	0
1	.	1	.	1	=	1	(Run Quit sequence as all three Keys were depressed)
.... as you can see the multiplication symbol (.) is a little misleading and that's why AND is often used in it's place

To keep it simple -- the AND operation only returns true if all it's variables are true, ie, Switch1 AND Switch2 AND .. SwitchN = True.

The NOT operation is alot simpler ... it basically inverts the value of a bit. Take this example for instance : As the result of another operation you want to invert the status of an indicator light from on to off, or off to on - inverting the current status of the light. In VB you may write something like this:

Dim bLight As Boolean	' Status light flag.
bLight = Not(bLight)

Linking it back to boolean algebra this translates as the following. Read it from right to left as in the above equations, ie, the result is a consequence of the logic to the left of the equal sign:

_____
bLight = bLight

The above boolean expression has the following possibilities (expressed using binary values) :

_____ bLight	=	Result
1	=	0	(Variable results as being inverted - in binary)
0	=	1	(Variable results as being inverted - in binary)
.... as you can see the overline symbol is weird! and that's why NOT is often used in it's place

The last of the Boolean Operations that you will probably need to understand will be the XOR operation (Exclusive OR operation) -- This one will be alittle tricky as it is a combination of NOT, AND, and OR operations all wrapped up into one!! The way it works is pretty much best left unexplained, it sooo much easier to remember the results than explain how the results are achieved. But! if you're curious send me an e-mail and I'll explain it as best I can, warning though, I'll explain it using circuit diagrams! ;o) .... The only important thing to remember will be that it requires two variables to give a result .. For now I'll just provide the lookup table:

The following boolean expression has the following possibilities (expressed using binary values) :

Switch1	Å	Switch2	=	Result
0	Å	0	=	0	(Result is false)
1	Å	0	=	1	(Result is true)
0	Å	1	=	1	(Result is true)
1	Å	1	=	0	(Result is false)
.... as you can see the EX-OR symbol is a little misleading and that's why XOR is often used in it's place

Basically this operation only returns true if only one of the switches are on ... Remember this and that's all it is to it! Now, if you've gotten through the Boolean Algebra unscaved then let's go back to the Raster Operations of the BitBlt API.

RasterOps!!

BitBlt allows you to transfer (merge, combine) source pixels to a destination .. more accurately, it performs this task by transferring the image data from one location to another. The Raster Operation parameter allows you to manipulate how the data is transferred. Lets take a look at the common raster operations and see what the results yield (incorporating what we've seen with Boolean Algebra expressions) ...

' SRCCOPY ........ Copies the source bmp to the destination .bmp ' SRCAND ......... Combines source bmp and dest. bmp using AND operator ' SRCINVERT ...... Combines source bmp and dest. bmp using XOR operator ' SRCPAINT ....... Combines source bmp and dest. bmp using OR operator

SRCCopy is simple. It doesn't use boolean operations on the image data. It transfers a copy of the image data to the destination. It's the others we really want to look at.

Now, consider this example: that the value of the colour WHITE is 1,1,1 (RGB: 11111111, 11111111, 11111111) and the value of colour BLACK is 0,0,0 (RGB: 00000000, 00000000, 00000000).

If a source pixel's colour is WHITE (1) and the destination pixel already has a value of 0 - BLACK performing the following Raster Operations will give you the following results :

SRCCOPY: Destination Pixel will be WHITE.
SRCAND: Destination Pixel will be BLACK.
SRCINVERT: Destination Pixel will be WHITE.
SRCPAINT: Destination Pixel will be WHITE.
and so on, and so on, check out the tables above!

Interesting eh? ;o) .... Now, what good is all this? Checkout some of my other tuts, including Transparency using Bitblt :o), they're too long to get into for this primer. On your own, try creating something like a progress bar out of two PictureBoxes. Start with something simple like, inverting the existing colour in the destination PictureBox, or something groovy like that!

Let's sum it up!

To use BitBlt API to copy from a picSource to picDestination:

You can set both PictureBoxes AutoRedraw properties set to True, and

the portion of picSource you want to Blt should be equal to or smaller than picDestination

Remember that if you set both PictureBoxe's Scalemode properties to Twips you should convert the appropriate values. Here's an example:

Call BitBlt(picDestination.hdc, _
               0, _
               0, _
               picSource.ScaleWidth \ Screen.TwipsPerPixelX, _
               picSource.ScaleHeight \ Screen.TwipsPerPixelY, _
               picSource.hDC, _
               0, _
               0, _
               SRCCOPY)

Now by calling the API function like this we're ignoring the return value of the function. The function will return zero if it fails. That should finish it up!

Simple as that! -- But now you know what it all means :o) If you want more information in the Tutorial, feel free to send comments or suggestions to me!

Michael Lambino
ProSoft@the18th.com

Copyright ©, 23 February, 1998 - Michael Lambino
Freeware - Freely distributable unmodified. No costs may be charged whatsoever for the distribution of this tutorial, in any form of media, without expressed permission from the author.

VB PacMan Tutorial

2008-01-28T12:19:00.001-08:00

pacman.bas

Declare Function BitBlt Lib "gdi32" (ByVal hDestDC As Long, ByVal X As Long, ByVal Y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal dwRop As Long) As Long
Public Const SRCAND = &H8800C6  ' (DWORD) dest = source AND dest
Public Const SRCCOPY = &HCC0020 ' (DWORD) dest = source
Public Const SRCINVERT = &H660046       ' (DWORD) dest = source XOR dest

Declare Function sndPlaySound Lib "winmm.dll" Alias "sndPlaySoundA" (ByVal lpszSoundName As String, ByVal uFlags As Long) As Long

Public Const dir_right = 0
Public Const dir_down = 1
Public Const dir_left = 2
Public Const dir_up = 3

Public Const mode_pacman_normal = 0
Public Const mode_pacman_powerup = 1
Public Const mode_ghost_wander = 2
Public Const mode_ghost_attack = 3
Public Const mode_ghost_escape = 4

Public m_sound As Integer

board.class

'local variable(s) to hold property value(s)
Private board_array(20, 20) As Integer
Private num_pills As Integer

Public Sub load_board(filename As String, pacman As Sprite, ghosts As Collection)
'load the level off disk into the board_array
Erase board_array
For a% = 1 To ghosts.Count
   ghosts.Remove (1)
Next
Y% = 1
num_pills = 0
If Dir$(filename) <> "" Then 'if the file exists
   ff% = FreeFile
   Open filename$ For Input As #ff%
       While Not EOF(ff%)
           Line Input #1, linein$
           For X% = 1 To Len(linein$)
               board_array(X%, Y%) = Asc(Mid$(linein$, X%, 1)) - 65 'subtract the letters
               Select Case board_array(X%, Y%)
                   Case 16, 17 'Q & R are pills
                       num_pills = num_pills + 1
                   Case 24 'Y = pacman
                       pacman.X = X%
                       pacman.Y = Y%
                       pacman.pills_ate = 0
                       pacman.mode = 0 'pacman=mode 0
                       board_array(X%, Y%) = 0
                   Case 25 'Z = ghost
                       Dim ghost As Sprite
                       Set ghost = New Sprite
                       ghost.mode = mode_ghost_wander
                       ghost.X = X%
                       ghost.Y = Y%
                       ghosts.Add ghost
                       Set ghost = Nothing
                       board_array(X%, Y%) = 0
               End Select
           Next
           Y% = Y% + 1 'move to next line down
       Wend
   Close
End If
End Sub

Public Sub drawcell(X As Integer, Y As Integer, dest_hdc As Long, sprite_hDC As Long)
   u! = BitBlt(dest_hdc, (X% - 1) * 32, (Y% - 1) * 32, 32, 32, sprite_hDC, (board_array(X%, Y%) Mod 4) * 32, (board_array(X%, Y%) \ 4) * 32, SRCCOPY)
End Sub

Public Sub paint(dest_hdc As Long, source_hdc As Long) 'Picture)
   'redraw the board on the specified image
   For X% = 1 To 20
       For Y% = 1 To 20
           u! = BitBlt(destination, (X% - 1) * 32, (Y% - 1) * 32, 32, 32, Source, (board_array(X%, Y%) Mod 4) * 32, (board_array(X%, Y%) \ 4) * 32, SRCCOPY)
       Next
   Next
End Sub

Public Property Let value(ByVal X As Integer, ByVal Y As Integer, ByVal vData As Integer)
'Syntax: board.value(x,y) = 5
   board_array(X, Y) = vData
End Property

Public Property Get value(ByVal X As Integer, ByVal Y As Integer) As Integer
'Syntax: Debug.Print board.value(x,y)
   value = board_array(X, Y)
End Property

Public Property Get pills() As Integer
   pills = num_pills
End Property

sprite.class

Private sp_mode As Integer
Private sp_score As Integer
Private sp_lives As Integer
Private sp_pills_ate As Integer
Private sp_anim As Integer
Private sp_animx As Integer, sp_animy As Integer
Private sp_x As Integer, sp_y As Integer
Private sp_oldx As Integer, sp_oldy As Integer
Private sp_direction As Integer
Private sp_frame As Integer
Private sp_powerup As Integer
Private step_size As Integer

Public Property Get pills_ate() As Integer
   pills_ate = sp_pills_ate
End Property

Public Property Let pills_ate(ByVal vData As Integer)
   sp_pills_ate = vData
End Property

Public Property Get pixelx() As Integer
   pixelx = sp_oldx
End Property

Public Property Get pixely() As Integer
   pixely = sp_oldy
End Property

Public Property Let score(ByVal vData As Integer)
   sp_score = vData
End Property

Public Property Get score() As Integer
   score = sp_score
End Property

Public Property Let lives(ByVal vData As Integer)
   sp_lives = vData
End Property

Public Property Get lives() As Integer
   lives = sp_lives
End Property

Public Property Let Y(ByVal vData As Integer)
   sp_y = vData
End Property

Public Property Get Y() As Integer
   Y = sp_y
End Property

Public Property Let X(ByVal vData As Integer)
   sp_x = vData
End Property

Public Property Get X() As Integer
   X = sp_x
End Property

Public Property Let mode(ByVal vData As Integer)
   sp_mode = vData
   sp_anim = 0
   If sp_mode <= mode_pacman_powerup Then 'pacman
       step_size = 8
   Else 'ghosts
       step_size = 5
   End If
End Property

Public Property Get mode() As Integer
   mode = sp_mode
End Property

Public Sub movesprite(key As Integer, pacman_x As Integer, pacman_y As Integer, pacman_mode As Integer, brdtmp As Board, board_hDC As Long, sprite_hDC As Long)
   Dim tmp_x As Integer, tmp_y As Integer, tmp_direction As Integer
   If sp_anim > 0 Then
       'doing the smooth transition
       If sp_anim * step_size >= 30 Then
           sp_anim = 0
           Select Case sp_direction
               Case dir_right: sp_x = sp_x + 1
               Case dir_down:  sp_y = sp_y + 1
               Case dir_left:  sp_x = sp_x - 1
               Case dir_up:    sp_y = sp_y - 1
           End Select
       Else
           sp_anim = sp_anim + 1
       End If
   Else
       'reached a point on the map,
       'ready to choose a new direction if appropriate
       flag% = True
       If sp_mode <= mode_pacman_powerup Then 'pacman
           Select Case key
               Case vbKeyLeft
                   tmp_x = sp_x - 1
                   tmp_y = sp_y
                   tmp_direction = 2
               Case vbKeyRight
                   tmp_x = sp_x + 1
                   tmp_y = sp_y
                   tmp_direction = 0
               Case vbKeyUp
                   tmp_x = sp_x
                   tmp_y = sp_y - 1
                   tmp_direction = 3
               Case vbKeyDown
                   tmp_x = sp_x
                   tmp_y = sp_y + 1
                   tmp_direction = 1
               Case Else
                   flag% = False
           End Select
           If flag% Then
               Select Case brdtmp.value(tmp_x, tmp_y)
                   Case 0, 18, 19 'floor
                       sp_anim = 1
                       sp_direction = tmp_direction
                   Case 16 'pill
                       sp_score = sp_score + 10
                       sp_anim = 1
                       sp_direction = tmp_direction
                       brdtmp.value(tmp_x, tmp_y) = 18
                       brdtmp.drawcell tmp_x, tmp_y, board_hDC, sprite_hDC
                       sp_pills_ate = sp_pills_ate + 1
                       If m_sound Then u! = sndPlaySound(App.Path & "\pacman1.wav", 1)
                   Case 17 'powerup
                       sp_score = sp_score + 40
                       sp_mode = mode_pacman_powerup
                       sp_anim = 1
                       sp_direction = tmp_direction
                       brdtmp.value(tmp_x, tmp_y) = 19
                       brdtmp.drawcell tmp_x, tmp_y, board_hDC, sprite_hDC
                       sp_pills_ate = sp_pills_ate + 1
                       If m_sound Then u! = sndPlaySound(App.Path & "\pacman2.wav", 1)
                       sp_powerup = 1
               End Select
           End If
           If sp_powerup > 0 Then
               sp_powerup = sp_powerup + 1
               If sp_powerup > 10 Then
                   sp_powerup = 0
                   sp_mode = mode_pacman_normal
               End If
           End If
       Else 'its a ghost
           If pacman_mode = mode_pacman_powerup Then
               'pacman has powered up, so runaway!
               sp_mode = mode_ghost_escape
               sp_powerup = 1
           End If
           If sp_mode <> mode_ghost_escape Then
               'check for proximity of pacman
               If Abs(sp_x - pacman_x) < 6 And Abs(sp_y - pacman_y) < 6 Then
                   'pacman is close, so attack
                   sp_mode = mode_ghost_attack
               Else
                   'pacman is far enough away to ignore
                   sp_mode = mode_ghost_wander
               End If
           End If
           tmp_x = sp_x
           tmp_y = sp_y
           Select Case sp_direction
               Case dir_right: tmp_x = sp_x + 1
               Case dir_down:  tmp_y = sp_y + 1
               Case dir_left:  tmp_x = sp_x - 1
               Case dir_up:    tmp_y = sp_y - 1
           End Select
           Select Case brdtmp.value(tmp_x, tmp_y)
               Case 0, 16, 17, 18, 19 'floor
                   If Int(Rnd(1) * 10) < 8 Then
                       '80% of the time continue in given direction
                       sp_anim = 1
                       newdirection% = False
                   Else
                       newdirection% = True
                   End If
               Case Else
                   'choose new direction
                   newdirection% = True
           End Select
           If newdirection% Then
               If sp_mode = mode_ghost_wander Then
               sp_direction = Int(Rnd(1) * 4)
               Else 'attack / escape
                   If sp_mode = mode_ghost_attack Then
                       Select Case Int(Rnd(1) * 10)
                           Case 0 To 3: whichdir% = 3 '40%
                           Case 4:      whichdir% = 2 '10%
                           Case 5 To 8: whichdir% = 4 '40%
                           Case Else:   whichdir% = 1 '10%
                       End Select
                   Else 'escape
                       Select Case Int(Rnd(1) * 10)
                           Case 0 To 3: whichdir% = 2 '40%
                           Case 4:      whichdir% = 3 '10%
                           Case 5 To 8: whichdir% = 1 '40%
                           Case Else:   whichdir% = 4 '10%
                       End Select
                   End If
                   Select Case whichdir%
                       Case 1 'away x
                           If pacman_x < sp_x Then sp_direction = dir_right
                           If pacman_x > sp_x Then sp_direction = dir_left
                       Case 2 'away y
                           If pacman_y < sp_y Then sp_direction = dir_up
                           If pacman_y > sp_y Then sp_direction = dir_down
                       Case 3 'towards x
                           If pacman_x > sp_x Then sp_direction = dir_right
                           If pacman_x < sp_x Then sp_direction = dir_left
                       Case 4 'towards y
                           If pacman_y > sp_y Then sp_direction = dir_up
                           If pacman_y < sp_y Then sp_direction = dir_down
                   End Select
               End If
           End If
           If sp_powerup > 0 Then
               sp_powerup = sp_powerup + 1
               Select Case sp_powerup
                   Case 17
                       sp_mode = mode_ghost_wander
                   Case 19
                       sp_mode = mode_ghost_escape
                   Case 20
                       sp_mode = mode_ghost_wander
                   Case 22
                       sp_mode = mode_ghost_escape
                   Case 23
                       sp_mode = mode_ghost_wander
                       sp_powerup = 0
               End Select
           End If
       End If
   End If
End Sub

Public Sub copysprite(form_hdc As Long, working_hdc As Long)
   u! = BitBlt(form_hdc, sp_oldx - 8, 30 + sp_oldy - 8, 48, 48, working_hdc, sp_oldx - 8, sp_oldy - 8, SRCCOPY)
End Sub

Public Sub erasesprite(working_hdc As Long, board_hDC As Long)
   u! = BitBlt(working_hdc, sp_oldx, sp_oldy, 32, 32, board_hDC, sp_oldx, sp_oldy, SRCCOPY)
End Sub

Public Sub drawsprite(working_hdc As Long, sprites_hdc As Long)
   sp_animx = 0
   sp_animy = 0
   Select Case sp_direction
       Case dir_right: sp_animx = sp_anim * step_size
       Case dir_down:  sp_animy = sp_anim * step_size
       Case dir_left:  sp_animx = -sp_anim * step_size
       Case dir_up:    sp_animy = -sp_anim * step_size
   End Select
   sp_oldx = (sp_x - 1) * 32 + sp_animx
   sp_oldy = (sp_y - 1) * 32 + sp_animy
  
   If sp_mode <= mode_pacman_powerup Then
       u! = BitBlt(working_hdc, sp_oldx, sp_oldy, 32, 32, sprites_hdc, 0, 5 * 32, SRCAND)
       u! = BitBlt(working_hdc, sp_oldx, sp_oldy, 32, 32, sprites_hdc, (sp_direction + 4) * 32, sp_frame * 32, SRCINVERT)
       If sp_anim <> 0 Then 'if moving then animate pacman eating
           If sp_frame = 1 Then sp_frame = 0 Else sp_frame = 1
       End If
   Else 'ghost
       If sp_mode = mode_ghost_escape Then
           u! = BitBlt(working_hdc, sp_oldx, sp_oldy, 32, 32, sprites_hdc, (4 + sp_frame) * 32, 5 * 32, SRCAND)
           u! = BitBlt(working_hdc, sp_oldx, sp_oldy, 32, 32, sprites_hdc, (4 + sp_frame) * 32, 4 * 32, SRCINVERT)
       Else
           u! = BitBlt(working_hdc, sp_oldx, sp_oldy, 32, 32, sprites_hdc, (4 + sp_frame) * 32, 3 * 32, SRCAND)
           u! = BitBlt(working_hdc, sp_oldx, sp_oldy, 32, 32, sprites_hdc, (4 + sp_frame) * 32, 2 * 32, SRCINVERT)
       End If
       sp_frame = sp_frame + 1
       If sp_frame > 3 Then sp_frame = 0
   End If
End Sub

usercontrol1

Private brdpac As Board
'brdpac holds the board class
Private Lastkey As Integer
'hold the last key pressed
Private pacman As Sprite
Private level As Integer
Private ghosts As New Collection


Private Sub copy_title_to_screen()
   u! = BitBlt(hDC, 0, 0, pictitle.ScaleWidth, pictitle.ScaleHeight, pictitle.hDC, 0, 0, SRCCOPY)
End Sub

Private Sub copy_working_to_screen()
   u! = BitBlt(hDC, 0, 30, picworking.ScaleWidth, picworking.ScaleHeight, picworking.hDC, 0, 0, SRCCOPY)
End Sub

Private Sub copy_board_to_working()
   u! = BitBlt(picworking.hDC, 0, 0, picboard.ScaleWidth, picboard.ScaleHeight, picboard.hDC, 0, 0, SRCCOPY)
End Sub



Private Sub Timer1_Timer()
'erase sprites
pacman.erasesprite picworking.hDC, picboard.hDC
For Each ghost In ghosts
   ghost.erasesprite picworking.hDC, picboard.hDC
Next

'move/draw sprites
pacman.movesprite Lastkey, pacman.X, pacman.Y, 0, brdpac, picboard.hDC, picsource.hDC
pacman.drawsprite picworking.hDC, picsource.hDC
For Each ghost In ghosts
   ghost.movesprite 0, pacman.X, pacman.Y, pacman.mode, brdpac, picboard.hDC, picsource.hDC
   ghost.drawsprite picworking.hDC, picsource.hDC
Next

'now copy sprites to the screen
pacman.copysprite hDC, picworking.hDC
For Each ghost In ghosts
   ghost.copysprite hDC, picworking.hDC
Next

'print the current score
print_score

'check if the level is complete
If pacman.pills_ate >= brdpac.pills Then
   level = level + 1
   load_level
End If

'check if pacman or ghost overlap
cur_ghost% = 1
For Each ghost In ghosts
   If Abs(ghost.pixelx - pacman.pixelx) < 32 And Abs(ghost.pixely - pacman.pixely) < 32 Then
       'you just got spooked
       If ghost.mode = mode_ghost_escape Then 'you got the ghost
           If m_sound Then u! = sndPlaySound(App.Path & "\pacman4.wav", 1)
           pacman.score = pacman.score + 400
           ghost.erasesprite picworking.hDC, picboard.hDC
           ghost.copysprite hDC, picworking.hDC
           ghosts.Remove cur_ghost%
           cur_ghost% = cur_ghost% - 1
       Else 'the ghost got you!
           If m_sound Then u! = sndPlaySound(App.Path & "\pacman3.wav", 1)
           pacman.lives = pacman.lives - 1
           load_level
       End If
   End If
   cur_ghost% = cur_ghost% + 1
Next
End Sub

Private Sub print_score()
   u! = BitBlt(hDC, 202, 7, 134, 16, pictitle.hDC, 202, 7, SRCCOPY)
   CurrentX = 204
   CurrentY = 8
   Print pacman.score
  
   u! = BitBlt(hDC, 436, 7, 96, 16, pictitle.hDC, 436, 7, SRCCOPY)
   CurrentX = 446
   CurrentY = 8
   Print pacman.lives
End Sub

Private Sub load_level()
   brdpac.load_board App.Path & "\level" & level & ".txt", pacman, ghosts
   'loadup the level off disk
   brdpac.paint picboard.hDC, picsource.hDC
   'draw the board into the buffer
   copy_board_to_working
   copy_working_to_screen
End Sub

Private Sub UserControl_Initialize()
   Set brdpac = New Board
   'give me a new board
   Set pacman = New Sprite
   'give me a new pacman
   pacman.lives = 3
  
   level = 1
   load_level
     
   Timer1.Enabled = True
End Sub

Private Sub UserControl_KeyDown(KeyCode As Integer, Shift As Integer)
 'just keep track of the last key, we will deal with direction later
   Lastkey = KeyCode
End Sub

Private Sub UserControl_Paint()
copy_working_to_screen
   copy_title_to_screen
   print_score
End Sub

Public Property Get sound() As Integer
   sound = m_sound
End Property

Public Property Let sound(ByVal New_sound As Integer)
   m_sound = New_sound
   PropertyChanged "sound"
End Property

'Initialize Properties for User Control
Private Sub UserControl_InitProperties()
   m_sound = m_def_sound
End Sub

'Load property values from storage
Private Sub UserControl_ReadProperties(PropBag As PropertyBag)
   m_sound = PropBag.ReadProperty("sound", m_def_sound)
End Sub

'Write property values to storage
Private Sub UserControl_WriteProperties(PropBag As PropertyBag)
   Call PropBag.WriteProperty("sound", m_sound, m_def_sound)
End Sub

Whack A Rat source code

2008-01-28T12:16:00.000-08:00

Source Code

Private Declare Function BitBlt Lib "gdi32" (ByVal hDestDC As Long, ByVal X As Long, ByVal Y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal dwRop As Long) As Long
Private Declare Function sndPlaySound Lib "winmm.dll" Alias "sndPlaySoundA" (ByVal lpszSoundName As String, ByVal uFlags As Long) As Long

Const SRCCOPY = &HCC0020 ' (DWORD) dest = source
Const SRCINVERT = &H660046       ' (DWORD) dest = source XOR dest
Const SRCAND = &H8800C6  ' (DWORD) dest = source AND dest

Dim handx%, handy% 'current hand position

Dim handpos% 'how far through a swing
Const hand_up = 0
Const hand_down = 1
Const hand_hit = 2

Dim ratx%(2, 2), raty%(2, 2), ratpos%(2, 2)
Dim ratspeed%(2, 2)

'hold the sprites
Dim spnx%(15), spny%(15), spnw%(15), spnh%(15), spnox%(15), spnoy%(15)

' game status
Dim difficulty% 'start at 0, (easy), 8=hard

' current frame (will just increment)
' (hopefully won't play till it overflows ;)
Dim frame As Long

'score
Dim score% '+/- 32000 should cover it

Private Sub Command1_Click()
frame = 0
score% = 0
Level% = Val(InputBox("Choose a difficulty from 0 to 8" & Chr$(13) & "8 being the hardest."))
If Level% > 8 Then difficulty% = 8 Else difficulty% = Level%
Timer1.Enabled = True
MousePointer = 99
End Sub

Private Sub Form_Load()
Randomize
u& = BitBlt(Picbuf.hDC, 0, 0, Picbuf.ScaleWidth, Picbuf.ScaleHeight, Picbak.hDC, 0, 0, SRCCOPY)
Timer1.Enabled = False
MousePointer = 0


'load up the sprites
Open App.Path & "\whack_img.spr" For Random As #1 Len = 2
For a% = 0 To 14
   Get #1, a% * 6 + 1, spnox%(a% + 1)
   Get #1, a% * 6 + 2, spnoy%(a% + 1)
   Get #1, a% * 6 + 3, spnx%(a% + 1)
   Get #1, a% * 6 + 4, spny%(a% + 1)
   Get #1, a% * 6 + 5, spnw%(a% + 1)
   Get #1, a% * 6 + 6, spnh%(a% + 1)
Next
Close #1

'position the rats over their holes
stickrat 0, 0, 187, 48, 0
stickrat 1, 0, 127, 79, 0
stickrat 2, 0, 75, 116, 0
stickrat 0, 1, 247, 58, 0
stickrat 1, 1, 189, 90, 0
stickrat 2, 1, 146, 126, 0
stickrat 0, 2, 304, 66, 0
stickrat 1, 2, 262, 98, 0
stickrat 2, 2, 222, 134, 0


End Sub

Sub stickrat(row%, col%, X%, Y%, pos%)
ratx%(row%, col%) = X%
raty%(row%, col%) = Y%
ratpos%(row%, col%) = pos%
End Sub

Private Sub Form_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single)
If handpos% = hand_up Then handpos% = hand_down
For col% = 0 To 2
   For row% = 0 To 2
       sp% = ratpos%(row%, col%)
       If sp% > 0 And sp% <= 12 Then 'this rat is trying to popup! If X> ratx%(row%, col%) + spnox%(sp%) And X  raty%(row%, col%) + spnoy%(sp%) And Y End Sub

Private Sub Form_MouseUp(Button As Integer, Shift As Integer, X As Single, Y As Single)
handpos% = hand_up
End Sub

Private Sub Form_MouseMove(Button As Integer, Shift As Integer, X As Single, Y As Single)
handx% = X - 15
handy% = Y - 40
End Sub

Private Sub Form_Paint()
u& = BitBlt(hDC, 0, 0, Picbuf.ScaleWidth, Picbuf.ScaleHeight, Picbuf.hDC, 0, 0, SRCCOPY)
End Sub

Private Sub Timer1_Timer()
'copy from background
u& = BitBlt(Picbuf.hDC, 0, 0, Picbuf.ScaleWidth, Picbuf.ScaleHeight, Picbak.hDC, 0, 0, SRCCOPY)

frame = frame + 1
popuprats

'update score and time
Picbuf.CurrentX = 90
Picbuf.CurrentY = 10
Picbuf.Print "Score : " & score%
Picbuf.CurrentX = 90
Picbuf.Print "Time  : " & (1000 - frame)
If frame = 1000 Then
   'thats the end of this game
   Timer1.Enabled = False
   MousePointer = 0
End If

'draw some rats
For col% = 0 To 2
   For row% = 0 To 2
       drawarat ratx%(row%, col%), raty%(row%, col%), ratpos%(row%, col%)
       updateRat row%, col%
   Next
Next

'place the sprite of the hand
drawhand

'copy to screen
u& = BitBlt(hDC, 0, 0, Picbuf.ScaleWidth, Picbuf.ScaleHeight, Picbuf.hDC, 0, 0, SRCCOPY)
End Sub

Sub drawhand()
Select Case handpos%
   Case hand_up
       u& = BitBlt(Picbuf.hDC, handx%, handy%, 97, 54, Picmsk.hDC, 0, 0, SRCAND)
       u& = BitBlt(Picbuf.hDC, handx%, handy%, 97, 54, Picimg.hDC, 0, 0, SRCINVERT)
   Case hand_hit
       u& = BitBlt(Picbuf.hDC, handx%, handy%, 90, 64, Picmsk.hDC, 0, 118, SRCAND)
       u& = BitBlt(Picbuf.hDC, handx%, handy%, 90, 64, Picimg.hDC, 0, 118, SRCINVERT)
   Case hand_down
       u& = BitBlt(Picbuf.hDC, handx%, handy% - 6, 90, 64, Picmsk.hDC, 0, 54, SRCAND)
       u& = BitBlt(Picbuf.hDC, handx%, handy% - 6, 90, 64, Picimg.hDC, 0, 54, SRCINVERT)
End Select
End Sub

Sub drawarat(X%, Y%, cell%)
If cell% > 0 Then
   u& = BitBlt(Picbuf.hDC, X% + spnox%(cell%), Y% + spnoy%(cell%), spnw%(cell%), spnh%(cell%), Picmsk.hDC, spnx%(cell%), spny%(cell%), SRCAND)
   u& = BitBlt(Picbuf.hDC, X% + spnox%(cell%), Y% + spnoy%(cell%), spnw%(cell%), spnh%(cell%), Picimg.hDC, spnx%(cell%), spny%(cell%), SRCINVERT)
End If
End Sub

Sub updateRat(row%, col%)
   If ratpos%(row%, col%) <= 12 And ratpos%(row%, col%)> 0 Then
       'if the rat has started popping up!
       'check if time has elapsed sufficent for the speed
       If frame Mod ratspeed%(row%, col%) = 0 Then
           'e.g. the bigger the speed, the less frequently it will
           'be an exact division (e.g. the slower the rat pops up)
           ratpos%(row%, col%) = ratpos%(row%, col%) - 1
           'change the frame
           If ratpos%(row%, col%) = 0 Then
               'the rat got away without a hit
               score% = score% - 20
           End If
       End If
   ElseIf ratpos%(row%, col%) > 12 Then
       If frame Mod ratspeed%(row%, col%) = 0 Then
           ratpos%(row%, col%) = ratpos%(row%, col%) + 1
           If ratpos%(row%, col%) >= 15 Then
               'finished animation, get rid of it
               ratpos%(row%, col%) = 0
           End If
       End If
   End If
End Sub

Sub popuprats()
   'randomly created rats popping up at random speeds
   'the harder the difficulty (higher the value)
   'the more likely and the faster the rats.
   If Int(Rnd(1) * (30 - difficulty%)) = 1 Then
       rndrow% = Int(Rnd(1) * 2.99)
       rndcol% = Int(Rnd(1) * 2.99)
       If ratpos%(rndrow%, rndcol%) = 0 Then
           ratpos%(rndrow%, rndcol%) = 12
           ratspeed%(rndrow%, rndcol%) = Int(Rnd(1) * (8 - difficulty%)) + 1
       End If
   End If
End Sub

Happy Programing
David Brebner

Mouse in a Maze VB Games

2008-01-28T12:13:00.000-08:00

Mouse in a Maze

By David Brebner

This is a very simple program that illustrates two interesting coding tricks.

1) Generating random mazes, which allow you to get from one point to any other.

2) Using the ClipCursor API call to restrict the mouse movement (in this case to allow you to only move within the valid area of the maze).

Making Mazes

Generating random mazes might seem like a complicated task, but their are plenty of algorithims available on the web to help you out. This particular one created mazes with interesting properties. Every maze created has no dead-ends, that means you can get from any one point to any other in any given maze.

The technique involves drawing a wall from every point in the maze in a random order and direction, until an exisiting wall is reached. Simple.

Mouse Herding

It is really very out of fashion to restrict the users mouse movement, however we have good reason for doing it this time. We want to make sure they aren't cheating, and just jumping over the walls straight to the finish.

So that people don't get frustrated, clicking the mouse releases them from the maze.

The main problem with mouse restrictions is they only apply to rectangular areas... So, how did I make an irregular maze type shape, you cry?

Creative use of ClipCursor

Because ClipCursor accepts only a RECT structure, we need to perform a trick to make the maze game work. That trick is to make a rectangle slightly bigger than each maze square. When the mouse reached the boundaries of the current maze square, we test to see if they are on a wall, or free space. If they are on free space, then we quickly whip up a new rectangle covering this new maze square. The mouse notices nothing because the squares overlap.

Declare Function ClipCursor Lib "user32" (lpRect As Any) As Long

The other API call we use is SetCursorPos to move the mouse into position at the start of the maze, we don't want any cheating in this era of competitive maze racing.

Happy Programming

Mouse in a Maze

Download the sample source code here ~ 11k,

David Brebner

Conclusion

2008-01-28T12:08:00.000-08:00

Conclusion

Now everything is nearly finished. I thought we could add some user feedback so that it is obvious when you are over a hotspot. Changing the cursor to a question mark seemed appropriate.

Private Sub Form_MouseMove(Button As Integer, Shift As Integer, X As Single, Y As Single)
Dim mp%, a
If List1.Visible = 0 And MousePointer <> 11 Then
   'as long as we are not making a choice,
   'or the hourglass isn't up
   mp% = 0
   For a = 1 To numactors
       If actor_cell(a) > 0 Then 'a valid cell
           'check rectangle
           If X > actor_x(a) + spnox(actor_cell(a), a) And X  actor_y(a) + spnoy(actor_cell(a), a) And Y <> mp% Then MousePointer = mp%
End If
End Sub

Another small thing that adds to the overall effect is the Form_paint event. Rather than drawing all the characters directly to screen, draw them to a buffer first. This is so users can't see the background drawn, then each actor drawn in turn. This not only looks unprofessional, but may give away your puzzles. Here is the replacement code, the only changes are that everything draws to ptmp.hdc (our temporary picturebox), then at the end copies the ptmp to the main form.

Private Sub Form_Paint()
Dim u%, a As Integer
'draw background
u% = BitBlt(ptmp.hDC, 0, 0, Picbuf.ScaleWidth, Picbuf.ScaleHeight, Picbuf.hDC, 0, 0, SRCCOPY)
'draw actors
For a = 1 To numactors
   If actor_cell(a) > 0 Then 'a valid cell
       If actor_mask(a) = 0 Then 'no mask
           u% = BitBlt(ptmp.hDC, actor_x(a) + spnox(actor_cell(a), a), actor_y(a) + spnoy(actor_cell(a), a), spnw(actor_cell(a), a), spnh(actor_cell(a), a), actor_images(a).hDC, spnx(actor_cell(a), a), spny(actor_cell(a), a), SRCCOPY)
       Else 'masked
           u% = BitBlt(ptmp.hDC, actor_x(a) + spnox(actor_mask(a), a), actor_y(a) + spnoy(actor_mask(a), a), spnw(actor_mask(a), a), spnh(actor_mask(a), a), actor_images(a).hDC, spnx(actor_mask(a), a), spny(actor_mask(a), a), SRCAND)
           u% = BitBlt(ptmp.hDC, actor_x(a) + spnox(actor_cell(a), a), actor_y(a) + spnoy(actor_cell(a), a), spnw(actor_cell(a), a), spnh(actor_cell(a), a), actor_images(a).hDC, spnx(actor_cell(a), a), spny(actor_cell(a), a), SRCINVERT)
       End If
   End If
Next
'copy the whole thing to screen
u% = BitBlt(hDC, 0, 0, Picbuf.ScaleWidth, Picbuf.ScaleHeight, ptmp.hDC, 0, 0, SRCCOPY)

End Sub

And finally things are pretty much done. To understand how this works, go through the code as I have described it, I have actually written the tutorial as I developed the blocks of code, so it really should work if you assemble it as I have described it. I find that as long as you consider the structure at the start, a program is most easily developed in bite sized chunks.

If you are interested in taking this further, some things I have not added to this engine that would enhance it might include;

Static hotspots that do not need a separate spr file

Irregular hotspots (e.g. see if the mouseclick falls inside the actors irregular shape)

Full-screen DirectX

Add Video playback to the action class

Provide actions for locations as well, these could be tied to game based events like timers, onentry and onexit.

Hope you enjoy the tutorial, and the sample adventure game.

Downloads

Just the source code ~ 20k

The full game & source code ~ 920k

VB5 system files if you don't have VB, and want to try it out (service pack3) ~ 1,360k

Enjoy
David Brebner

Now the section that draws the animation.

2008-01-28T12:06:00.000-08:00

Now the section that draws the animation.

This is the bottom half of the subroutine started in the previous page.

Don't get to hung up on the long winded bitblt calls, they are really fairly simple, it just gets a bit messy. To see what is going on read the comments.

p.s.

ca% stands for current actor (in the animation)

sp% = sprite cell

lsp% = last sprite cell

msk% = mask

       
       '***********************************************
       '      now perform the animation itself
       '***********************************************
       Dim crow%(40)
       Dim tim1&, tim2&, u&
       Dim currentframe%, ff%, ca%, c%
       Dim sp%, lsp%, msk%
      
       ptmp.Cls
       'backup the image into the tmp buffer (ptmp)
       u& = BitBlt(ptmp.hDC, 0, 0, Picbuf.ScaleWidth, Picbuf.ScaleHeight, Picbuf.hDC, 0, 0, SRCCOPY)
              
       currentframe% = 1
       a% = 1
       tim1& = GetTickCount 'start timing
       Do
           'do the bitblt
           For ca% = 1 To num 'number of actors
               ff% = False
                   Do
                   c% = abuf(ca%, crow%(ca%), 0)
                   If c% = currentframe% Then
                       'do the blting
                       sp% = abuf(ca%, crow%(ca%), 3)
                       lsp% = abuf(ca%, crow%(ca%) - 1, 3)
                       msk% = abuf(ca%, crow%(ca%), 4)
                      
                       If sp% > 0 Then
                           If msk% = 0 Then '*********** normal block
                               u& = BitBlt(hDC, abuf(ca%, crow%(ca%), 1) + spnox%(sp%, apic(ca%)), abuf(ca%, crow%(ca%), 2) + spnoy%(sp%, apic(ca%)), spnw%(sp%, apic(ca%)), spnh%(sp%, apic(ca%)), actor_images(apic(ca%)).hDC, spnx%(sp%, apic(ca%)), spny%(sp%, apic(ca%)), SRCCOPY)
                           ElseIf msk% < 0 Then '******* block set to clean up (-1)
                               'draw block to tmp
                               u& = BitBlt(ptmp.hDC, abuf(ca%, crow%(ca%), 1) + spnox%(sp%, apic(ca%)), abuf(ca%, crow%(ca%), 2) + spnoy%(sp%, apic(ca%)), spnw%(sp%, apic(ca%)), spnh%(sp%, apic(ca%)), actor_images(apic(ca%)).hDC, spnx%(sp%, apic(ca%)), spny%(sp%, apic(ca%)), SRCCOPY)
                               'copy old block from tmp to screen
                               If lsp% > -1 Then u& = BitBlt(hDC, abuf(ca%, crow%(ca%) - 1, 1) + spnox%(lsp%, apic(ca%)), abuf(ca%, crow%(ca%) - 1, 2) + spnoy%(lsp%, apic(ca%)), spnw%(lsp%, apic(ca%)), spnh%(lsp%, apic(ca%)), ptmp.hDC, abuf(ca%, crow%(ca%) - 1, 1) + spnox%(lsp%, apic(ca%)), abuf(ca%, crow%(ca%) - 1, 2) + spnoy%(lsp%, apic(ca%)), SRCCOPY)
                               'copy new block from tmp to screen
                               u& = BitBlt(hDC, abuf(ca%, crow%(ca%), 1) + spnox%(sp%, apic(ca%)), abuf(ca%, crow%(ca%), 2) + spnoy%(sp%, apic(ca%)), spnw%(sp%, apic(ca%)), spnh%(sp%, apic(ca%)), ptmp.hDC, abuf(ca%, crow%(ca%), 1) + spnox%(sp%, apic(ca%)), abuf(ca%, crow%(ca%), 2) + spnoy%(sp%, apic(ca%)), SRCCOPY)
                               'clean up tmp again
                               u& = BitBlt(ptmp.hDC, abuf(ca%, crow%(ca%), 1) + spnox%(sp%, apic(ca%)), abuf(ca%, crow%(ca%), 2) + spnoy%(sp%, apic(ca%)), spnw%(sp%, apic(ca%)), spnh%(sp%, apic(ca%)), Picbuf.hDC, abuf(ca%, crow%(ca%), 1) + spnox%(sp%, apic(ca%)), abuf(ca%, crow%(ca%), 2) + spnoy%(sp%, apic(ca%)), SRCCOPY)
                           Else '************************ sprite (cleans up automatically)
                               'draw sprite to tmp
                               u& = BitBlt(ptmp.hDC, abuf(ca%, crow%(ca%), 1) + spnox%(msk%, apic(ca%)), abuf(ca%, crow%(ca%), 2) + spnoy%(msk%, apic(ca%)), spnw%(msk%, apic(ca%)), spnh%(msk%, apic(ca%)), actor_images(apic(ca%)).hDC, spnx%(msk%, apic(ca%)), spny%(msk%, apic(ca%)), SRCAND)
                               u& = BitBlt(ptmp.hDC, abuf(ca%, crow%(ca%), 1) + spnox%(sp%, apic(ca%)), abuf(ca%, crow%(ca%), 2) + spnoy%(sp%, apic(ca%)), spnw%(sp%, apic(ca%)), spnh%(sp%, apic(ca%)), actor_images(apic(ca%)).hDC, spnx%(sp%, apic(ca%)), spny%(sp%, apic(ca%)), SRCINVERT)
                               'copy old block from tmp to screen
                               If lsp% > -1 Then u& = BitBlt(hDC, abuf(ca%, crow%(ca%) - 1, 1) + spnox%(lsp%, apic(ca%)), abuf(ca%, crow%(ca%) - 1, 2) + spnoy%(lsp%, apic(ca%)), spnw%(lsp%, apic(ca%)), spnh%(lsp%, apic(ca%)), ptmp.hDC, abuf(ca%, crow%(ca%) - 1, 1) + spnox%(lsp%, apic(ca%)), abuf(ca%, crow%(ca%) - 1, 2) + spnoy%(lsp%, apic(ca%)), SRCCOPY)
                               'copy new block from tmp to screen
                               u& = BitBlt(hDC, abuf(ca%, crow%(ca%), 1) + spnox%(sp%, apic(ca%)), abuf(ca%, crow%(ca%), 2) + spnoy%(sp%, apic(ca%)), spnw%(sp%, apic(ca%)), spnh%(sp%, apic(ca%)), ptmp.hDC, abuf(ca%, crow%(ca%), 1) + spnox%(sp%, apic(ca%)), abuf(ca%, crow%(ca%), 2) + spnoy%(sp%, apic(ca%)), SRCCOPY)
                               'clean up tmp again
                               u& = BitBlt(ptmp.hDC, abuf(ca%, crow%(ca%), 1) + spnox%(sp%, apic(ca%)), abuf(ca%, crow%(ca%), 2) + spnoy%(sp%, apic(ca%)), spnw%(sp%, apic(ca%)), spnh%(sp%, apic(ca%)), Picbuf.hDC, abuf(ca%, crow%(ca%), 1) + spnox%(sp%, apic(ca%)), abuf(ca%, crow%(ca%), 2) + spnoy%(sp%, apic(ca%)), SRCCOPY)
                           End If
                       ElseIf msk% < 0 Then 'even though no current sprite,clean up anyway
                           If lsp% > 0 Then u& = BitBlt(hDC, abuf(ca%, crow%(ca%) - 1, 1) + spnox%(lsp%, apic(ca%)), abuf(ca%, crow%(ca%) - 1, 2) + spnoy%(lsp%, apic(ca%)), spnw%(lsp%, apic(ca%)), spnh%(lsp%, apic(ca%)), ptmp.hDC, abuf(ca%, crow%(ca%) - 1, 1) + spnox%(lsp%, apic(ca%)), abuf(ca%, crow%(ca%) - 1, 2) + spnoy%(lsp%, apic(ca%)), SRCCOPY)
                       End If
                   End If
                   If c% <= currentframe% Then
                       If crow%(ca%) < 500 Then crow%(ca%) = crow%(ca%) + 1
                   Else
                       ff% = True
                   End If
               Loop Until ff% = True Or crow(ca%) > 499
           Next
           Do
               u& = DoEvents
               tim2& = GetTickCount
           Loop Until tim2& > tim1& + (currentframe% * 45)
           currentframe% = currentframe% + 1
       Loop Until currentframe% >= size%
   End If
End If
End Sub

The GetTickCount is initialised at the start of each frame, once the bitblt is complete, it will sit looping at the end until the time exceeds its inital value + the current time. The advantage of this technique is that if the animation is going to slowly, in slack times (no animation going on), it will usually catch up.

Enjoy
David Brebner

Animation

2008-01-28T12:04:00.001-08:00

Animation

The final addition to this tutorial is the ability to play back an animation. Now I am going to cheat slightly here - I am going to use an animation editor I have written to create the animation files. Essentially it is a visual tool that lets me position actor_editor SPR files along a timeline and test the animation.

If you want to make your own animations you will need to create them using a text editor (not quite so interactive), or create your own editor. (p.s. I will probably not release my editor because it is tightly tied to several projects I am working on at the moment)

All that aside we need to determine a format, load it on demand, and play our animation in time. One of the tricks we need to consider is moving sprites may need to clean up behind themselves (replace the background image), while some may want to simply paint onto the background. We will tell if they need cleaning up if the animation frame has a non-zero mask value. A negative mask value indicates this frame actually has no mask (its just rectangular) but it does need to be cleaned up after.

To achieve the effect of replacing the background as images move we need to keep an of-screen buffer for our animations to occur. This will keep the animation smooth and free from flicker.

The timing will be done using a simple API call, gettick. This returns a regularly incrementing long integer. This is much more accurate than using a timer control, and allows us to easily drop code into the animation section of the list1.click event.

Animation File Structure

For convenience I will use a text conversion of my animation editor file format. This allowed me to quickly create the animations for this tutorial.

The format is

Background image
Number of words to by synched with animation
 Frame#, word
Number of actors in this animation
 Actor Image
 Number of frames of animation
 Frame#,x,y,cell,mask

The cool thing about this format is that the frame# is stored so if an actor does not move for part of an animation you don't need to record heaps of individual identical frames. This format also allows (although we won't be using it) for synched text to be highlighted as the animation progresses, e.g. highlight the word when the frame# is reached.

To make the animation possible, we need to be able to identify quickly which picture is loaded into which actor_image. We can exploit the tag property of a picturebox to store this. Add the following 4 lines to the start of the Load_Graphics_For_Location routine.

   'first wipe tagged names from picture controls
   For d% = 1 To 40
       actor_images(d%).Tag = ""
   Next

Then add these two lines just before you load the sprite file data.

            'so we can later match the actor with the animation
           actor_images(numactors).Tag = actor.SpriteFile

Now the main PlayAnimation subroutine. This is fairly big - so I will describe it in two halves.

First the part that loads the animation from file;

Sub PlayAnimation(anim As String)
Dim tmp As String, tmpn As Integer
Dim num As Integer, numa As Integer
Dim a%, b%, size%
'to hold the temporary animation data
'an animation buffer to hold 40 actors,
'500 frames and 5 entries per frame.
Dim abuf(40, 500, 4) As Integer
Dim apic(40) As Integer 'pointer back to picture
Dim backslash As Integer

If anim <> "" Then
   If Dir$(App.Path & "\" & anim & ".anm") <> "" Then
       '***********************************************
       ' the animation file exists so load it all up!!!
       '***********************************************
       'p.s. the animation frames will be stored in temporary arrays
       Open App.Path & "\" & anim & ".anm" For Input As #1
       Input #1, tmp 'backgound image
       'number of word entries (ignore)
       Input #1, num
       'text entries themselves
       For a% = 1 To num
           Input #1, tmpn, tmp '(just ignore)
       Next
      
       'the number of actors
       Input #1, num
       'read in all the actors data
       For a% = 1 To num
           'read the actors name
           Input #1, tmp
           'now find the actor in the image buffer
           For b% = 1 To 40
               'this line checks (non-case sensitive) if the
               'current actor_image matches the current actor from file
               backslash = InStr(1, tmp, actor_images(b%).Tag, vbTextCompare)
               If backslash > 0 And actor_images(b%).Tag <> "" Then
                   If Mid$(tmp, backslash - 1, 1) = "\" And Mid$(tmp, backslash + Len(actor_images(b%).Tag), 1) = "." Then
                       'save a pointer back to this actor_image
                       apic(a%) = b%
                       Exit For
                   End If
               Else
                   apic(a%) = 1
               End If
           Next
           'read the num of actor frames
           Input #1, numa
           'read the frames from disk
           For b% = 1 To numa
               Input #1, abuf(a%, b%, 0), abuf(a%, b%, 1), abuf(a%, b%, 2), abuf(a%, b%, 3), abuf(a%, b%, 4)
               'update the biggest frame#
               If abuf(a%, b%, 0) > size% Then size% = abuf(a%, b%, 0)
           Next
       Next
       'done!!
       Close

This essentially allocates a great big integer array called abuf (animation buffer) to hold all the animation data. This is then filled up with the information from the files. The only complex part is that when a sequence of frames for an actor is read, we need to establish in which actor_image control the picture resides. This is the reason for filling the .tag property with the filename when we load the actors in the Load_Graphics_for_Location routine.

This code steps though each picture checking if the tag matches with the text in the animation file. (instr checks for a match, and the VBTextCompare constant makes it case insensitive).

Once we have established which picture this animation character maps to, we put it into the apic array. (animation picture)

Enjoy
David Brebner

Lets make our actions do something

2008-01-28T11:57:00.000-08:00

Lets make our actions do something

Now we have given the user a selection of actions to choose from, we need to do something when they select one. We need to write the action processing routines. This should be child's play compared to the Expression evaluation.

Private Sub List1_Click()
   Dim u As Long
   List1.Visible = 0
   If List1.ListIndex >= 0 Then
       MousePointer = 11 'hourglass
       'cool, the user has chosen an action
       Dim actor As New Actor_Class
       'the actor number we stored the list tag property
       Set actor = actors(List1.Tag)
       Dim actor_state As New Actor_State_Class
       Set actor_state = actor.States(actor.State)
       Dim actor_action As New Actor_Actions_Class
       'using the action index we stored in the list itemdata array
       Set actor_action = actor_state.Actions(List1.ItemData(List1.ListIndex))
       'We are up and running with the action!
      
       'play sound
       If Len(Trim(actor_action.Sound)) > 0 Then
           If Dir$(App.Path & "\" & actor_action.Sound) <> "" Then
               u = sndPlaySound(App.Path & "\" & actor_action.Sound, 1)
           End If
       End If

       'display response if there is one.
       If actor_action.Response <> "" Then
           Label1.Caption = actor_action.Response
       End If

       'play animation here
      
       'when animation complete, change states
       If actor_action.NewStates <> "" Then
           'p.s. actors on this page also need update the arrays
           'states are seperated by spaces, e.g. A200=2 A302=4
           Dim token As String, cond As String
           Dim sp As Integer, op As Integer, equals As Integer
           Dim lnum As Integer, rnum As Integer, a As Integer
                      
           cond = actor_action.NewStates & " "
           sp = 1: op = 1
           Do 'consume tokens until gone.
               sp = InStr(sp + 1, cond, " ")
               If sp > 0 Then
                   token = Trim(Mid$(cond, op, sp - op))
                   lnum = Val(Right$(token, Len(token) - 1))
                   equals = InStr(token, "=")
                   If equals > 0 Then rnum = Val(Right$(token, Len(token) - equals))
                   'now change the actor or locations state
                   If Left$(token, 1) = "A" Then 'actor
                       Set actor = actors(Trim(Str(lnum)))
                       actor.State = rnum
                       'update the actors in the array
                       Set actor_state = actor.States(Trim(Str(rnum)))
                       For a = 1 To numactors
                           If actor_number(a) = actor.Number Then
                               actor_x(a) = actor_state.X
                               actor_y(a) = actor_state.Y
                               actor_cell(a) = actor_state.cell
                               actor_mask(a) = actor_state.mask
                               Exit For
                           End If
                       Next
                   Else 'location
                       Dim location As New Location_Class
                       Set location = locations.Item(Trim(Str(lnum)))
                       location.State = rnum
                       'reload graphics if at this location
                       If lnum = mylocation Then Load_Graphics_for_Location
                   End If
               End If
               op = sp
           Loop Until sp = 0
       End If
      
       'change location
       If actor_action.NewLocation <> "" Then
           mylocation = Val(actor_action.NewLocation)
           Load_Graphics_for_Location
       End If
      
       Form_Paint 'repaint the page
       MousePointer = 0 'normal
   End If
End Sub

Now you can really see it coming together. You can now click on actors, the available actions are displayed. When you select an action states change, locations change and sounds play - only animation to go.

Enjoy
David Brebner

Free Online Tutorials for Photoshop Autocad Rapidshare

free auto cad programs

1) Quick screen-shot demonstration of how eMachineShop works:

Custom fabrication was never this streamlined, cost-effective, and enjoyable.

Download Free Autocad viewer

How to search rapidshare on Google

100an drama ji rapidshare wang yi

Music Hero-Guitar Lesson Nine

Guitar Lesson Eight - Theory

Part II:

Harmonizing Scales:

Theory -Guitar Lesson Seven

Theory Part I

Introduction-Guitar Lesson Six

Introduction

How to play Guitar

General Tips-Guitar Lesson Four

General Tips

Tuning MIDI-Guitar Lesson Three

THEORY

Bass-Guitar Lesson Two

Theory

Tuning up-Guitar Lesson One

Tuning up

Isometric Triangular Dot Paper printable

Cornell Lined

Cornell Music

3D ISOMETRIC DRAWING

Architectural Desktop

What are the main poblems in SolidWorks

Crazy Lips Games

MP3 Sharing Community

NOS Logo, Website, Accounting and Sales

SUM Agency Logo and Website

Web Design: From Good to Great in 25 Links

From Good to Great, One link at a time

40+ Excellent Free Fonts For Professional Design

9 Essential Principles for Good Web Design

Whitespace

Elements of Great Web design: The Polish

35 Designers x 5 Questions

34 Places to Get Design Inspiration (On and Off)

8 Web Design Tactics to Help You When You're Stuck

42 Design/Tech Magazines To Read

100 Awesome High Resolutions Photoshop Brushes

30 More Excellent Blog Designs

Web Page Analyzer

Starting a design blog from the ground up

Best Practices for Bulletproof E-Mail Delivery

7 Surefire Styles that Work

20 of the Best E-Commerce Websites

Plain text templates and formatting tips

Time Savers: Code Beautifier And Formatter

Applying progressive enhancements to your website

Exploring Design: Outstanding Start Pages

Who is hosting this

Human-to-Human Design

60 Elegant And Visually Appealing Designs

50 Ways to Become a Better Designer

iStockphoto

11 Almost Perfect Business Layout

Free Seo Tools

free search submission

seo tools

seo references

Ajax Resources

Miscellaneous tools

Miscellaneous tools

Top Quality Photoshopped Images

How To Use Rapidshare

Real Time Pixel Manipulation in VB5

DirectDraw for Visual Basic®

The BitBlt API

VB PacMan Tutorial

pacman.bas

board.class

sprite.class

usercontrol1

Whack A Rat source code

Mouse in a Maze VB Games