Tag Archives: Code

File Server and Client Using Sockets in C++

Sending the client to itself, effectively overwriting it while its running.

Find downloads at the bottom of this post!
I wanted to make an application in C++ using sockets and threads to test myself and get familiar with C++. It took me a couple of days and this is what I came up with.
It is an application to easily transmit a file in a LAN.
It works by running “server ” in a CLI, this will start the server which will advertise its presence and transmit its file to anyone who connects to it. By “advertise” I mean it will open a UDP socket to listen for incoming broadcasts from clients.
On another computer you run the client from a CLI which will query for file servers in the LAN by broadcasting a UDP packet to the file server UDP port, present its findings and you can then choose which file to download.

Background

I first started working with sockets in Visual Basic 6 when I was 12 years old. I started out creating a chat application, which at that point took me weeks and never worked properly.
In the past couple of years I’ve been diving back in to it, by creating a lot of unfinished multiplayer games with .NET(C# and VB) and GameMaker. I love LAN games and I really wish there were more of them, but it seems I am not patient enough to create them, at least not alone.
I’m currently taking a course in networking in which we’ve implemented a chat application in Python. It is extremely easy to set up sockets in Python and can even be accomplished by running the Python environment in a terminal, which makes it really cool for debugging.
I’m really eager to try out network programming in Unity3D as it seems completely different from what I am used to; it uses RPCs as far as I can tell.

Code

I use the Boost library to achieve a cross platform implementation of sockets and threads. This did not work out. I spent hours trying to compile the project with MinGW, I eventually gave up and tried with Visual Studio which I got working rather quickly. But then the applications started crashing and acting weird because apparently sockets are only thread safe in Boost if you’re using Linux and some other bugs I don’t have the patience to uncover cropped up, like the client randomly appending characters to filenames and ports when splitting them. I successfully sent and received files from Windows<->Linux and Windows<->Windows, albeit with crashes, but that’s the best I can do without rewriting the entire thing. And it’d probably be easier to just write a Windows specific solution rather than using Boost. But for some reason it still felt really awesome sending a file from a Linux laptop to a Windows desktop.
I haven’t put much weight on the structure of the code and spent most of the time digging around in Boost documentation. Right now it works, but it is really cluttered and a lot of stuff could probably be removed, since it is only there because I thought it would work at some point in time, but it didn’t and I am too lazy to refactor the code, since this was just a test.
I only wrote one file per executable, no header, no classes, no nothing(so a lot of something, I guess). I commented every section of the code to make it easier to understand for people wanting to learn.
I also learned about static linking from making this project. It’s something I guess you don’t know about when you’ve grown up with IDEs and very high level languages which handle most of the linking hassle for you. But apparently you can just put whatever libraries you’re using in the compiled executable, which will make it larger but also self contained, i.e. no darn dependencies!
Dependencies have always been a bitch for me; I couldn’t show off my first games when I was a kid since they would only run on my own PC(GameMaker was a dream come true). Sometimes I find it hard to find dependencies and package them properly; to this day I still don’t know how to deploy MonoDevelop/GTK projects short of just including the entirety of MonoDevelop in the package, which really sucks since I wanted to use it for a Linux/Windows game. I wonder how Unity3D does it?

Ideas for expansion

Multiple file servers on one host: You could alter the server so that if the UDP port is taken it will send its filename and endpoint to the UDP port so the currently running fileserver can advertise its presence for it. You could also just make a single fileserver handle more files, but that would make it more complicated and defeat the purpose of the project, i.e. easy file transfer.
More customizability: Most of the options are hardcoded; port numbers, buffer size, etc., simply because I was too lazy to handle arguments.

Download

Without further ado:

Linux binaries

Windows binaries(UNSTABLE!)

Commented source files

Fresnel shader in Unity(With source)

Leave a reply

I was just messing around with shaders in Unity while working on a game. I’ve never really tried making a shader before because I feel the math is intimidating, but it is actually pretty simple once you get into it. I’ve always liked the fresnel effect; it looks cool for microbiological illustrations and it’s nice for highlighting stuff.

The way it works is that you take the dot product of the direction vector of the camera and the normal of the current pixel being rendered on the model(See picture below). The dot product will go from 1 to 0(assuming that we’re dealing with unit vectors(we are)) the closer these vectors are to being perpendicular and the closer these vectors are to being perpendicular the closer the pixel is to the edge of the model being rendered in relation to the camera. You then take the inverse of the dot product, i.e. 1 – (cameraDirection · normal), and you multiply it with the color you want. The color then gets more intense the closer you get to the edge of the model, as you can see in the picture above. If you add a bump map to this, the surface normals get distorted and the fresnel effect distorts with it, which looks really cool as you can see in the bottom two spheres on the right, in the picture above.

The white lines are the normals of the sphere; the outward direction of the face.

Anyway, feel free to use it in your own projects as much as you want, link in the comments if you wanna show off something you’ve made with it. Here’s the source:

Shader "Custom/FresnelShader" {
	Properties {
	 	_Shininess ("Shininess", Range (0.01, 3)) = 1

	 	_MyColor ("Shine Color", Color) = (1,1,1,1) 

		_MainTex ("Base (RGB)", 2D) = "white" {}

		_Bump ("Bump", 2D) = "bump" {}

	}
	SubShader {
		Tags { "RenderType"="Opaque" }
		LOD 200

		CGPROGRAM
		#pragma surface surf Lambert

		sampler2D _MainTex;
		sampler2D _Bump;
		float _Shininess;
		fixed4 _MyColor; 

		struct Input {
			float2 uv_MainTex;
			float2 uv_Bump;
			float3 viewDir;
		};

		void surf (Input IN, inout SurfaceOutput o) {
			half4 c = tex2D (_MainTex, IN.uv_MainTex);
			o.Normal = UnpackNormal(tex2D(_Bump, IN.uv_Bump));
			half factor = dot(normalize(IN.viewDir),o.Normal);
			o.Albedo = c.rgb+_MyColor*(_Shininess-factor*_Shininess);
			o.Emission.rgb = _MyColor*(_Shininess-factor*_Shininess);
			o.Alpha = c.a;
		}
		ENDCG
	} 
	FallBack "Diffuse"
}

Procedurally generated tree(With source)

Leave a reply

I was bored one day so I sat down and tried making a random tree generator. Essentially it’s extremely simple, you basically have this:

struct Tree
    {
    int x, y, z;
    float radius;
    Tree[] subTrees;
    }

It’s a root which defines a point in R³, a thickness and branches connected to it. From this structure I can generate a tree by recursively traversing the structure, building cylinders as I go:

AddCylinder(int x1, int  y1, int  z1,
            int  x2, int  y2, int  z2,
            float w1, float w2, 3DModel model)
    {
    //Construct cylinder from (x1,y1,z1) with raidus w1 to (x2,y2,z2) with radius w2
    //Add cylinder to model
    }

BuildTree(Tree node, 3DModel model)
    {
    foreach(Tree subTree in node.subTrees)
        {
        AddCylinder(node.x, node.y, node.z,
                    subTree.x, subTree.y, subTree.z,
                    node.radius, subTree.radius, model);
        BuildTree(subTree, model)
        }
    }

The interesting part of all this is finding an algorithm which generates cool trees. My algorithm was kind of half-assed, I have a much better idea now than I did when I was motivated to implement it. I was thinking of having three cases and then choosing between them: “Stop here”, “Continue growing” or “Branch out”. Then it would be a simple problem of choosing what would be best at any given time. My current algorithm is implemented like “I just want to see if it works”.

(Note that the “leaves” are icosahedrons stolen from my first post)

As you can see the approach I have to constructing the cylinders is not as great as it could have been. The ends are always on an XY plane, or aligned with the floor. I could’ve rotated them so they were facing the direction they’re growing in and then connected them with an extra cylinder at each node:

The generator has the potential of building really realistic trees by adding a lot more small branches and adding a lot of small leave sprites instead of big spheres added to the end of each branch.

It’s written in C# using .NET 3.5 and TrueVision3D(DLL included). Here’s the source:

Download Here

File: TreeGen.rar

Contents: C# Solution and TrueVision3D assembly.

Size: ~4.5 MB

Subdivision of icosahedrons

19 Replies

In this post I will explain how to build, subdivide and texture an icosahedron. Look at the ending of the post for eye candy.

So I’ve been following the development of Notch’s new game, 0x10^c, which is looking really exciting. When I saw a screenshot(Can’t find it now) I was reminded of something I read about using icosahedrons to make planets in 3D with minimal distortion when mapping to a texture.

I find this way of attacking the problem of spheres fascinating. Basically you start off with a 20 sided die and split the faces by adding new vertices on a sphere encapsulating the icosahedrons, so in each iteration you get closer to a perfect sphere. You split the faces by adding a point in the middle of each edge in a triangle, you then construct four new triangles using these and the original vertices.

Continue reading →