Update README, add CONTRIBUTING and LICENSE

Author: jgranick

CONTRIBUTING.md

@@ -0,0 +1,18 @@
+How To Contribute
+=================
+
+We welcome your feedback and input in how to make Lime better!
+
+If you are interested in discussing new features, the direction the project or how to integrate some change, please open an issue so we can talk about.
+
+ 1. Fork the repository
+ 
+ 2. Make the desired change
+ 
+ 3. Create a pull request
+
+
+You may consider creating a branch specific to the fix or improvement you wish to make, in case you have more than one that has not been accepted into the project, or to allow for item-specific changes.
+
+It is our goal to help Lime evolve as a clean, easy-to-use (but powerful) layer for cross-platform development. Thanks for being a part of making this possible!
+

LICENSE.md

@@ -0,0 +1,24 @@
+License
+=======
+
+The MIT License (MIT)
+
+Copyright (c) 2007-2014 OpenFL Technologies, LLC and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.

README.md

@@ -1,74 +1,151 @@
-#lime 
----
-light media engine   
-A lightweight OpenGL framework for [haxe](http://haxe.org).
+Lime
+====
 
-![lime](lime.png)
+![Lime](lime.png)
 
+Introduction
+------------
 
-A starting point for building OpenGL applications across Mac, Windows, Linux, Blackberry, HTML5(WebGL), Android, iOS and more.
+Lime (Light Media Engine) is an abstraction layer that makes it simple to go cross-platform with only one codebase; without the compromise of relying upon a scripting language or a virtual machine.
 
-#What it does
-	
-lime exposes the following
+Lime leverages the power of the [Haxe](http://haxe.org/) programming language, compiling Haxe code directly to C++, JavaScript and other target languages. Haxe is a flexible, robust language, and the resulting applications are truly native.
 
-- OpenGL
-- Audio
-- Input
-- Windowing
-- Useful native features
+Platforms
+---------
 
-By setting up a bootstrap for your application, lime will handle all the low level events and call into your main class (this can be overridden) for you. 
+Lime currently supports the following platforms:
 
-#How it works
+ * Windows
+ * Mac
+ * Linux
+ * iOS
+ * Android
+ * BlackBerry
+ * Tizen
+ * Emscripten
+ * HTML5
 
-lime is a cross platform haxe library powered by [lime-tools](http://github.com/openfl/lime-tools), for building upon opengl across many platforms. 
+With legacy support for:
 
-### lime is two parts
-**One part** is the native code, the underlying platform templates and systems to expose the features.    
-**The second part** is the haxe wrapper, forwarding the events to your application.
+ * webOS
+ * Flash
 
-For example, frameworks like [OpenFL](http://github.com/openfl) leverage lime to implement a cross platform Flash API by leaning on the native portion, without using the current lime haxe classes at all.
+What It Does
+------------
 
-#Things to note
+Lime exposes the following:
 
-- lime (native, and wrapper) are low level. It does the bare minimum to give you access to the metal - without making it difficult.
-- The lime wrapper works by default by bootstrapping your application main class into the framework. 
-- The lime wrapper will call functions into your class, for mouse, keys, gamepad and other system or windowing events (resizing, for example). Then, you handle them.
-- The lime wrapper exposes an API to talk to the windowing, audio and other API's across platforms.
+ * OpenGL
+ * Audio
+ * Input
+ * Windowing
+ * Useful native features
+ 
+By setting up a bootstrap for your application, Lime will handle all of the low-level events, and call into your main class (this can be overridden) for you.
 
-- The lime GL wrapper code is based on WebGL Api. It matches very closely. Including types and constants.
-- The lime native parts were forked from [nme](http://github.com/haxenme/nme) (native media engine) and merged into  openfl-native - but now (and lastly) been merged into lime and joined forces to create an agnostic, cross platform starting point to widen the haxe landscape for all frameworks and framework developers.
-- See the wiki for a 1.0 wrapper [roadmap](https://github.com/openfl/lime/wiki/lime-wrapper-1.0-Roadmap). 
+The rendering API is very similar to WebGL, which in turn is similar to OpenGL ES. This enables us to support your code on platforms using OpenGL, OpenGL ES and WebGL. 
 
-Expect docs, diagrams and breakdowns of how to get started using lime soon. See the examples/ folder for the basics for now.
+How It Works
+------------
 
-# Using Development Builds
+Lime comes together in three different parts.
+
+The **first** are command-line tools, which manage the build, package, install and run process for each support platform.
+
+The **second** is a native layer, which handles rendering, sound and other features with hand-written C++ (with a small amount of Objective-C and Java) in order to handle the core of each platform. This layer is not used when targeting HTML5.
+
+The **third** is a Haxe wrapper (under development), which exposes this functionality and helps abstract differences (such as HTML5 vs native builds)
+
+Lime is designed to power higher-level frameworks, in addition to exposing a sensible cross-platform API for "more direct" development. Most popularly, Lime is also used as the foundation for [OpenFL](https://github.com/openfl/openfl) which is an open-source, accelerated version of the Flash API, supporting all of the Lime targets as well as an HTML5 canvas implementations of the Flash API as well.
+
+License
+-------
+
+Lime is free, open-source software under the MIT license.
+
+Installing Lime
+---------------
+
+First you will need to first install Haxe 3.0 for [Windows](http://haxe.org/file/haxe-3.0.0-win.exe), [Mac](http://haxe.org/file/haxe-3.0.0-osx-installer.dmg) or [Linux](http://www.openfl.org/download_file/view/726/12426/).
+
+Once Haxe has been installed, you can install a release version of Lime from a terminal or command-prompt with these commands:
+
+    haxelib install lime
+    haxelib run lime setup
+
+Some platforms will require some additional setup before you can use them. For example, you must have Visual Studio C++ in order to build native applications for Windows. Lime includes a "setup" command that can help you walk through the process for each target:
+
+    lime setup windows
+    lime setup android
+    lime setup blackberry
+    lime setup tizen
+    lime setup emscripten
+    lime setup webos
+
+In order to build for Mac or iOS, you should already have a recent version of Xcode installed. In order to build for Linux, usually only g++ is required, which may be installed with your distribution already. No setup is required for these platforms.
+
+Development Builds
+------------------
+
+If you would like to begin using Lime directly from the repository, or want to help contribute to its development, you will first want to clone the repository (or your fork of the repository) then tell "haxelib" where your development version is installed. You will also need to clone [lime-build](https://github.com/openfl/lime-build), which includes static libraries and headers required to recompile the Lime native layer from the source.
 
     git clone https://github.com/openfl/lime
     haxelib dev lime lime
     git clone https://github.com/openfl/lime-build
     haxelib dev lime-build lime-build
 
-After cloning, "lime/ndll" will be empty. You can build binaries for a platform, use "lime rebuild" or "openfl rebuild", such as:
+The "lime/ndll" directory will be empty, but you can easily rebuild the binaries for any platform using "lime rebuild", like:
 
     lime rebuild windows
     lime rebuild windows,blackberry
     lime rebuild linux -64
     lime rebuild android -debug
 
-If you are running Linux, you will (probably) need to install additional packages to build from the source. For an Ubuntu system, it may look like this:
+Most platforms do not require additional dependencies (other than usual dependencies) to rebuild, but if you are running linux you will development libraries for GL and GLU, as well as multilib versions of g++ if you plan to rebuild both 32- and 64-bit versions of the Lime native layer (which is done through "rebuild" by default)
 
     sudo apt-get install libgl1-mesa-dev libglu1-mesa-dev g++ g++-multilib gcc-multilib
-    
-For other platforms, the dependencies will be similar to compiling standard Lime/OpenFL applications for the platform, for example, you will need Visual Studio for Windows builds, Xcode for Mac and iOS builds, etc. Platforms which require "setup" step, such as Android, should have that completed, such as "lime setup android"
 
-The default "rebuild" for each target compiles all needed binaries, such as x86, armv5 and arm7 for release and debug. You can use "-debug", "-release", "-64" and "-32" to specify that you only want to rebuild one kind of binary. You can use commas to separate multiple builds.
+By default, "rebuild" will compile every binary needed for a target, including both release and debug, and for certain platforms, multiple architectures (such as x86 for an emulator or arm for a device). You can use "-debug", "-release", "-64" and "-32" to specify that you only want to rebuild one kind of binary, and you can use commas to separate multiple builds, in the same command.
 
-There is also a helpful "-rebuild" flag you can use in combination with other Lime/OpenFL commands, to rebuild the required binaries in addition to the meaning of the original command. For example, this will test the current application for Windows, while first building release platform binary before packaging:
+There is also a helpful "-rebuild" flag you can use, that rebuilds only the required Lime binary, in addition to the meaning of the original command. For example, the following will test the current application, rebuilding the Windows release binary for Lime first:
 
     lime test windows -rebuild
 
-To return to release builds:
+To return to release builds of Lime, use:
 
     haxelib dev lime
+
+Using Lime
+----------
+
+If you prefer a low-level API, you may want to use Lime directly. The Lime 1.0 wrapper is still under development, you can see the wiki for the 1.0 [roadmap](https://github.com/openfl/lime/wiki/lime-wrapper-1.0-Roadmap).
+
+You can get a taste by trying the "SimpleOpenGL" or "HerokuShaders" samples:
+
+    lime create lime:SimpleOpenGL
+    cd SimpleOpenGL
+    lime test linux
+
+You can substitute "HerokuShaders" for "SimpleOpenGL" in the above command, or use "lime create" to see all available samples. The "test" command combines "update", "build" and "run" into one step. If you are not running Linux, or would like to use a different target, you can try one of the following as well:
+
+    lime test windows
+    lime test mac
+    lime test ios
+    lime test ios -simulator
+    lime test android
+    lime test android -emulator
+    lime test blackberry
+    lime test blackberry -simulator
+    lime test tizen
+    lime test tizen -simulator
+    lime test emscripten
+    lime test html5
+    lime test webos
+    lime test webos -simulator
+
+If you do not prefer a low-level API, [OpenFL](https://github.com/openfl/openfl) is currently the easiest way to use Lime. Instead of making direct OpenGL calls, OpenFL uses a much simpler (but powerful) API, on top of the functionality of Lime. For example, in order to display an image, OpenFL would use:
+
+    var bitmap = new Bitmap (Assets.getBitmapData ("image.png"));
+    addChild (bitmap);
+
+This is far fewer steps than using OpenGL directly, so you should decide what level of API you prefer, even if you are not familiar (or do not prefer) the Flash API, as OpenFL also allows direct OpenGL calls using "OpenGLView" if you prefer.