I have put this site together to display some of the computer software I have created to colleges, scholarships, and internships I am applying for. The most complete and promising software I have made to this date is something called Rendition Script. It is not just a simple program but rather a tool and a concept. Basically, it is my own computer programming language. What sets this apart from other languages is that it is intended for the user instead of the programmer. I intend to license this software very soon and distribute it to programmers who need user programming functionality in their applications. Please read the user's guide for more information about what Rendition Script is and how to use it.
In order to make Rendition Script functional, I have written over 5,000 lines of code spanning over 20 files in a time period of about one year. My system works by taking the user's script (basic text) and putting it through three "layers". This process takes immense attention to detail and logic. Every possible situation must be accounted for.
I started this language because I saw a great use for it in the computer world. With today's complex applications like Excel, Word, and even Internet Explorer, there needs to be a simple, yet powerful, language to expose a common interface to the application's functions and processing structure.
As a side note; I began to write Rendition Script using C# and the .NET framework but I decided that C++ was ultimately the language to use. Links to both versions are listed below. The C# program has more features completed, but the C++ version is much faster and more efficient using no more than 1 MB of memory with an average length script. There is a slight difference in instruction names between the two versions. Namely, in the C++ version, the instruction to declare a variable is "single" instead of "memory".
For a detailed description of Rendition Script's programming structure, click here.
C++ Version Demo - So far, this is the only program that uses the C++ version of Rendition Script but it is important to note that C# applications can use the C++ version library through its interop services. C# demo's are below.
Visual Rendition Script is a program I made to visually create Rendition Scripts. It is basically an IDE for Rendition Script. There are four windows displayed by default. The first is the "code editor" window. This is where the user edits and creates new scripts that are activated by button presses. The next window is the "interface layout" window. This is where controls can be added and moved to create a visual form for users to interact with. When buttons are added to the layout window, there is an option for what script to attach to the button that will be triggered when the button is clicked. The next window is the "script manager" window. This is an outline of all the scripts used by the user's program. New groups and scripts can be added in this window. The last window is the "property editor" window. This window serves the purpose of editing the visual components in the "interface layout" window. When a control is clicked, its properties show up in the "property editor". Changes made in the "property editor" will be reflected in the "interface layout" window. Application settings can also be edited from the "property editor".
NOTE: You must have Microsoft .NET Framework installed for these programs to work. Most computers should have the Framework installed already.
Visual Rendition Script (Rendition Script library included) - Uses the C# version of Rendition Script.
Image Script is another program I made to apply Rendition Script. It is an image processing program that takes a user's script and transforms each color channel of an image based on their script. This program alone (separate from Rendition Script) is composed of over 1,400 lines of code and I have also worked on this program in conjunction with Rendition Script for about eight months. Please note that both Image Script and Rendition Script are NOT complete. They are both close to completion but both have bugs and incomplete features that I am aware of.
Image Script (Rendition Script library included) - Uses the C# version of Rendition Script.
User Calculator is a program I made to simply demonstrate Rendition Script. It uses current features such as input, output, and external variables.
User Calculator (Rendition Script library included) - Uses the C# version of Rendition Script.
Graph Script is a program that allows users to type in any equation and the program will graph it out, similar to a graphing calculator except the equations will be inputted via a Rendition Script.
Graph Script (Rendition Script library included) - Uses the C# version of Rendition Script.
As I gained knowledge of 3d graphics and vertex / pixel shaders, I wanted to apply that knowledge outside the realm of video games. I decided to bring the powerful features of graphics cards to the desktop. Most modern computers have vertex / pixel shader capability so why not utilize that power with standard applications? My 3d GUI is available for demonstration below but has limited functionality. I plan to make 3d models and implementations for all controls including buttons, text boxes, radio buttons, check boxes, and many more; all having properties and events you would expect from traditional 2d controls as well as additional properties accommodating the 3d space. I also plan to support a control that projects 2d controls not supported by my 3d GUI onto a 3d quad which can then be rotated, lit, etc.
The interface has a class heirarchy that begins with class Control3D. All other controls are derived from that base class. To keep track of all the controls to be drawn, I created a Form3D class that is basically a container for all the controls to be drawn in the current interface. In addition to acting as a container, the Form3D class also handles input / output and events. For example, the Form3D class makes calculations to see if the user clicked on a 3D control.
NOTE: You must have Microsoft .NET Framework and DirectX installed for the 3d interface to work. Most computers should have both of these installed already.
3d Interface - Interface demo containing a push button, checkbox, and progress sphere
For a detailed description of my 3d interface's programming structure, click here.
I have made many programs separate from Rendition Script and my 3d interface. I consider these other programs to be amateurish, or insignificant, but they still took hard work, dedication, planning, testing and debugging, and a large amount of time.
Box Game - Make boxes by connecting dots. Online and CPU features incomplete. (Written in C#. Requires .NET Framework)
Code Creator - Take ordinary text and transform it into unreadable code or decode encoded text. Must fully unzip with folder structure intact. (Requires Borland C++ Runtime)
Also, I have created many other small 3d applications and demonstrations. I will only give portions of the code since the programs will most likely not work on your computer because they require a gaming video card that supports vertex / pixel shaders. It is just important to know that those programs make extensive use of vectors, scalars, and matrices. This math / physics involvement greatly interests me and is one of my main focuses for my career (although the logical part of programming also interests me as in Rendition Script.)
The following are examples of programs called vertex shaders. Things to note about the vertex shaders are that a float is a decimal number, a float4 is a vector, and a float4x4 is a four dimensional matrix. I have created the pixel shaders also, but they are simple and mostly the same so I will not include them.
This program uses matrices to rotate a quad displaying an arbitrary image. The core of this program is the "CreateRotMatrix4D_Z" function. What this does is create a 4D matrix (the 4th dimension used for translations which is useless in this program) that rotates vertices about the Z-axis. The program is written in HLSL (a high level language similar to C++):
float4x4 view_proj_matrix: register(c0);
float4x4 quad_scale: register(c4);
float time_0_X: register(c8);
float z_rot: register(c9);
float cos_time_0_X: register(c11);
float sin_time_0_X: register(c12);
float tan_time_0_X: register(c13);
float4x4 CreateRotMatrix4D_Z(float theta)
{
return float4x4( cos(theta), sin(theta), 0, 0,
-sin(theta), cos(theta), 0, 0,
0, 0, 1, 0,
0, 0, 0, 1 );
}
float4 CreateDiffuse()
{
float4 color = float4(1, 1, 1, 1);
color.r *= max(0.5, cos_time_0_X);
color.g *= max(0.5, sin_time_0_X);
color.b *= max(0.5, tan_time_0_X);
return color;
}
struct VS_OUTPUT
{
float4 Pos: POSITION;
float4 Diffuse: COLOR;
float2 TexCoord:TEXCOORD;
};
VS_OUTPUT vs_main( float4 inPos: POSITION, float2 inTexCoord: TEXCOORD )
{
VS_OUTPUT Out;
float4x4 quad_rotate = CreateRotMatrix4D_Z(z_rot * time_0_X);
Out.TexCoord = inTexCoord;
Out.Diffuse = CreateDiffuse();
Out.Pos = mul(mul(view_proj_matrix, mul(quad_scale, quad_rotate)), inPos);
return Out;
}
This program uses a cube map and a diffuse lighting formula to give a reflective look. The core of this program is the creation of the reflection vector. With this vector, the cube map can be correctly mapped to the vertices. The program is written in ASM which is the low level version of HLSL:
vs_1_1
//Used in reflection formula
def c6, -2, 0, 0, 0
dcl_position v0
dcl_normal v1
//Put vertex and normal into world projection space
m4x4 oPos, v0, c0
m3x3 r1, v1, c0
//Normalize the normal
dp3 r1.w, r1, r1
rsq r1.w, r1.w
mul r1, r1, r1.w
//Dot the normal and light position
dp3 oD0, r1, c5
//Get reflection vector and output it to texcoord
dp3 r0.w, c4, v1
mul r1.w, r0.w, c6.x
mad oT0.xyz, r1.w, v1, c4
**Thanks for reading through this whole site. If you have any questions or comments please call or e-mail me:
Phone: 920-471-2311
E-Mail: peplins4@uwm.edu