| |
| |
Linear Deformation Plugin for MeshLab
Implemented a plugin using QT Creator on Linux for the MeshLab geometry processing research platform.
This plugin allows a closed manifold triangular mesh to be deformed according to user handle translation.
Project Files
|
 |
Recursive Mesh Simplification Plugin for MeshLab
This plugin allows a closed manifold triangular mesh to be simplified by vertex removal
using a priority queue data structure for finding the face to remove with the least amount of error.
Simplification is by one vertex at a time, or a cycle until a face target is reached.
Parameters for max angle sensitivity are added to help preserve mesh features.
Project Files
|
 |
Root 3 Subdivision Plugin for MeshLab
Implemented a plugin using QT Creator on Linux for the MeshLab geometry processing research platform. This plugin allows a closed manifold triangular mesh to be subdivided
using the root-3 method described by Leif Kobbelt's paper 'Root-3 Subdivision'. Specifically, I inserted new vertices in each of the original faces breaking them up into three, then used MeshLabs data structures to do one-ring traversals on each vertex, creating a new face when a spoke of the ring traversal exists in the original mesh. I then add some vertex positioning refinement to the original vertices, smoothing the surface.
sqrt3subdiv.cpp
Project Files
Kobbelt PDF
|
 |
Influence Mapped Cellular Automata Mod for the Source SDK
The environmental influence map helps direct the behavioral states of each NPC
by giving them a potential to remain in their state unless provoked by an outside
influence. A cellular automata model allows neighborhoods of NPCs to influence one another. The player acts as an influence upon the NPCs by becoming an influential
factor in the environmental state. The environmental influence map is dynamically
updated to account for the location of the player in relation to NPCs. The simultaneous
effect of the player’s proximity to the NPC is to heighten the alertness of the NPC, and
force the environmental influence to adopt an alert state influence at the corresponding
map location. The result is a dynamic environmental influence upon the NPCs, with the
player’s movements controlling the influence.
|
|
Randomized Generic Actor NPC Entity for Valve's Hammer World Editor
To create the random NPCs, the CRandomGenericActor class is created as a
duplicated extension of the CGenericActor class provided by the Source SDK, and modified in
order to directly interface with a custom AI engine ( Automata class described in my thesis) for randomization. The source code for Valve's generic_actor is modified such that upon spawn, an NPC is
randomly assigned a model and texture. This modification is in the source code of the
NPC, and uses functionality present in the Automata class randomize() function. When
the Automata class is instanced and the randomize() function called, the randomized
texture and model set is determined, letting the NPC grab this information when it
spawns into the map.
|
|
Influence Map Pre-visualization Tool
A tool for a 2D visualization, or pre-visualization, was made
isolate a cellular automata behavioral model for testing and fine-tuning parameters, while saving development time.
The tool gives the user controls to evolve or pause the model, clear the grid, and
step forward one generation at a time. A randomization control allows the user to
completely randomize the model at any time during the simulation. The pre-visualization
is useful because influence maps can be tested and their effect on the general behavior
model evaluated before implementation into a game engine.
Project Files
|
|
| TCP Chat Server |
This program used BSD sockets to implement a chat server. Included in this
implementation is the use of pThreads, Semaphores, and Shared memory.
BSD sockets are used to allow a server to open a TCP connection for
communication between clients talking through the same TCP port.
Pthreads are used to listen to each client as they send their messages to the
group.
Shared memory is used to keep track of file descriptors for each client, as they
come and go from the server.
Semaphores are used to keep out simultaneous access to shared memory.
server.cpp
Project Files
|
Producer-Consumer
with Shared Memory |
The producer reads an image file, and simultaneously writes to shared memory
while the consumer who reads from shared memory writes to an out outfile. This program uses semaphores and a small buffer size
producer.c
consumer.c
Project Files
|
| XOR Encryption |
This program uses an XOR shift to encrypt a file with a User supplied max 256 bit passphrase. It will read the file specified by 'infile' and write it to 'outfile'
Upon start, the program will ask for a passphrase
for the encryption. If the file is already encrypted, it will be decrypted.
xor.cpp
Project Files
|
| Kernel Sampler |
This program takes samples of the system's processes
and computes running averages for various values.
ksamp.cpp
Project Files
|
| Kernel Timer |
This program profiles a parent and two children processes in order to use
itimer and signal facilities. The processes profiled are computing numbers
from the fibonacci sequence, namely, the parent is computing fib(30), the
child1 is computing fib(34), and the child2 computes fib(40).
kerneltimer.c
kerneltimer_fib.c
Project Files
|
| Simple Shell |
This program creates a simple shell with limited functionality
In my implementation I used C++ to save time, but whence I learned
that the execve() command took char* const* args I was doomed to find
that I had do resort to old fashioned C to get the right structures in place.
The result is a program written all in C++ with the C style memory allocation
quarantined in one method.
myshell.cc
simpleshell.cc
Project Files
|
| Custom FTP-ish Client |
This program interfaces with a FTP similar protocol for accessing filesystems and retreiving files.
It uses control socket file descriptors. It implements PWD, CWD, INFO, LIST, RETR, QUIT, HELP.
msstpclient.cpp
Project Files
|
| Windows Process Launcher |
This program implements a simplified shell which uses Windows Threads
to execute in turn applications specified in a list.
launch.cpp
MyProcess.cpp
Project Files
|
|
|
|
