CSG & Solid BSP

By admin - Last updated: Mardi, mars 27, 2012



A new article is comming soon about an old but very interesting technique for CSG.

Filed in 3D •

Full software openGL rewrite in java

By admin - Last updated: Lundi, février 13, 2012

Just for fun i write a small rasterizer engine 100% in java (no java 3d). It mimic opengl immediate mode.

Features are:





Sample code for the Sierpinski Gasket. As you can see it very easy.

?View Code JAVA
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

package samples;
 
import fuzzGl.CGlCore;
import fuzzGl.Glenum;
import fuzzGl.backBuffer.CBackBuffer;
import fuzzGl.geometry.Vertex2;
 
public class CSierpinskiGasket3DSmooth extends CSamplesBase
{
    int m_width=0;
    int m_height=0;
    static double r=0.0;
    static int RECURSTION_DEPTH=3;
 
    @Override
    public void init(CBackBuffer bb)
    {
        CGlCore.setBackBuffer(bb);
        c=CGlCore.getInstance();
        m_width=bb.getWidth();
        m_height=bb.getHeight();
    }
 
    @Override
    public void update()
    {
        if (c==null)
        return;
 
        c.glClearColor(0.0,0.0,0.0,1.0);
 
        c.glEnable(Glenum.GL_DEPTH_TEST);
        c.glClearDepth(100.0);
 
        c.glEnable(Glenum.GL_CULL_FACE);
        c.glCullFace(Glenum.GL_BACK);
 
//        c.glShadeModel(Glenum.GL_FLAT);
 
        c.glClear(Glenum.GL_COLOR_BUFFER_BIT);
        c.glClear(Glenum.GL_DEPTH_BUFFER_BIT);
 
        c.glViewport(0,0,m_width,m_height);
 
        c.glMatrixMode(Glenum.GL_PROJECTION);
        c.gluPerspective( 45.0, m_width/m_height, 0.001, 100.0 );
 
        c.glMatrixMode(Glenum.GL_MODELVIEW);
        c.glLoadIdentity();
        c.gluLookAt(
                0.0,0.0,5.0,
                0.0,0.0,0.0,
                0.0,1.0,0.0);
 
        c.glPushMatrix();
 
        c.glRotated(r,0.0,1.0,0.0);
        c.glRotated(r,0.0,0.0,1.0);
 
        c.glScaled(6.0,6.0,6.0);
 
        SierpinskiGasket3f(0.7,5);
        c.glPopMatrix();
 
        c.glFlush();
 
        r+=0.2;
    }
 
void SierpinskiGasket3f_A(Vertex2 _point0Arr, Vertex2 _point1Arr, Vertex2 _point2Arr, Vertex2 _point3Arr, int _count)
{
	if(_count > 0)
	{
		//reduce count
		_count -= 1;
 
		//new points array
		Vertex2 newPoint01Arr=new Vertex2();
		Vertex2 newPoint12Arr=new Vertex2();
		Vertex2 newPoint20Arr=new Vertex2();
		Vertex2 newPoint03Arr=new Vertex2();
		Vertex2 newPoint13Arr=new Vertex2();
		Vertex2 newPoint23Arr=new Vertex2();
 
		//fill points
        newPoint01Arr.setLerp(_point0Arr, _point1Arr,0.5);
        newPoint12Arr.setLerp(_point1Arr, _point2Arr,0.5);
        newPoint20Arr.setLerp(_point2Arr, _point0Arr,0.5);
        newPoint03Arr.setLerp(_point0Arr, _point3Arr,0.5);
        newPoint13Arr.setLerp(_point1Arr, _point3Arr,0.5);
        newPoint23Arr.setLerp(_point2Arr, _point3Arr,0.5);
 
		//  sub-triangle 1
		SierpinskiGasket3f_A(newPoint01Arr, _point1Arr, newPoint12Arr, newPoint13Arr, _count);
 
		//  sub-triangle 2
		SierpinskiGasket3f_A(newPoint12Arr, _point2Arr, newPoint20Arr, newPoint23Arr, _count);
 
		//  sub-triangle 3
		SierpinskiGasket3f_A(newPoint01Arr, _point0Arr, newPoint20Arr, newPoint03Arr, _count);
 
		//  sub-triangle 4
		SierpinskiGasket3f_A(newPoint03Arr, newPoint13Arr, newPoint23Arr, _point3Arr, _count);
	}
	else
	{
		//draw faces
		//side 0 (bottom)
		c.glColor4f(1, 0, 0, 1); //0
		c.glVertex3d(_point0Arr.posClip.x,_point0Arr.posClip.y,_point0Arr.posClip.z);
		c.glColor4f(0, 0, 1, 1); //2
		c.glVertex3d(_point2Arr.posClip.x,_point2Arr.posClip.y,_point2Arr.posClip.z);
        c.glColor4f(0, 1, 0, 1); //1
        c.glVertex3d(_point1Arr.posClip.x,_point1Arr.posClip.y,_point1Arr.posClip.z);
 
		//side 1
		c.glColor4f(1, 0, 0, 1); //0
		c.glVertex3d(_point0Arr.posClip.x,_point0Arr.posClip.y,_point0Arr.posClip.z);
		c.glColor4f(0, 1, 0, 1); //1
		c.glVertex3d(_point1Arr.posClip.x,_point1Arr.posClip.y,_point1Arr.posClip.z);
		c.glColor4f(0.7, 0.7, 0.7, 1); //3
		c.glVertex3d(_point3Arr.posClip.x,_point3Arr.posClip.y,_point3Arr.posClip.z);
 
		//side 2
		c.glColor4f(0, 1, 0, 1); //1
		c.glVertex3d(_point1Arr.posClip.x,_point1Arr.posClip.y,_point1Arr.posClip.z);
		c.glColor4f(0, 0, 1, 1); //2
		c.glVertex3d(_point2Arr.posClip.x,_point2Arr.posClip.y,_point2Arr.posClip.z);
		c.glColor4f(0.7, 0.7, 0.7, 1); //3
		c.glVertex3d(_point3Arr.posClip.x,_point3Arr.posClip.y,_point3Arr.posClip.z);
 
		//side 3
		c.glColor4f(0, 0, 1, 1); //2
		c.glVertex3d(_point2Arr.posClip.x,_point2Arr.posClip.y,_point2Arr.posClip.z);
		c.glColor4f(1, 0, 0, 1); //0
		c.glVertex3d(_point0Arr.posClip.x,_point0Arr.posClip.y,_point0Arr.posClip.z);
		c.glColor4f(0.7, 0.7, 0.7, 1); //3
		c.glVertex3d(_point3Arr.posClip.x,_point3Arr.posClip.y,_point3Arr.posClip.z);
	}
}
 
 
    void SierpinskiGasket3f(double _rad, int _count)
    {
        Vertex2 points0Arr=new Vertex2(); points0Arr.posClip.setFromDouble(_rad, 0, 0,0);
        Vertex2 points1Arr=new Vertex2(); points1Arr.posClip.setFromDouble(_rad*(-0.5f), _rad*(0.866025404f), 0,0);
        Vertex2 points2Arr=new Vertex2(); points2Arr.posClip.setFromDouble(_rad*(-0.5f), _rad*(-0.866025404f), 0,0);
        Vertex2 points3Arr=new Vertex2(); points3Arr.posClip.setFromDouble(0, 0, _rad,0);
        c.glBegin(Glenum.GL_TRIANGLES);
        SierpinskiGasket3f_A(points0Arr, points1Arr, points2Arr, points3Arr, _count);
        c.glEnd();
    }
 
 
    @Override
    public void deinit()
    {
    }
}

Some screen shots:

Filed in 3D, java •

Metaballs and reflection with raymarching

By admin - Last updated: Vendredi, février 10, 2012

simple way to render iso surface, but is definitely not the faster.

Download Video: MP4



Get the fragment shader here

?View Code GLSL
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

#version 130
 
uniform vec2 resolution;
 
uniform vec3 pos1;
uniform vec3 pos2;
uniform vec3 pos3;
uniform vec3 pos4;
 
vec4 fpar00[16];
 
#define size  0.4
 
struct s_ray
{
		vec3 origin;
		vec3 direction;
};
 
s_ray		ray;
 
float pot(vec3 at, vec3 ballCenter)
{
	vec3 tmp=at-ballCenter;
	float d=dot(tmp,tmp);
	return d;
}
 
 
 
float field(vec3 p) 
{
	float potentiel=0.0;
 
	potentiel += size/pot(p,pos1);
	potentiel += size/pot(p,pos2);
	potentiel += size/pot(p,pos3);
	potentiel += size/pot(p,pos4);	
	return 1.0-potentiel;
}
 
bool intPlane( in vec4 plane, in s_ray ray, in float tm, out float t )
{
    t = -(dot(plane.xyz,ray.origin)+plane.w)/dot(plane.xyz,ray.direction);
    return (t > 0.0) && (t < tm);
}
 
bool trace(s_ray ray, in float maxDistance, in out float t )
{
	float minDistance = 0.3;
	float distance = 999.0;
	while (t < maxDistance)
	{
		vec3 position = ray.origin + t * ray.direction;
		distance = field(position);
		if (distance < minDistance && distance>0.0)
		{
			break;
		}			
		t += 0.02;
	}
	return (distance < minDistance && distance>0.0);
}
 
void Render_plans(s_ray ray, out vec3 position,out vec4 ob,out vec4 co, in float tm, out float t )
{
	if (intPlane(fpar00[0],ray, tm,t))  //left
	{ ob = fpar00[0]; co = vec4(1,1,1,1); tm = t; }
	if (intPlane(fpar00[1],ray,tm,t)) //right
	{ ob = fpar00[1]; co = vec4(0,1,0,1); tm = t; }
	if (intPlane(fpar00[2],ray, tm,t)) //top
	{ ob = fpar00[2]; co = vec4(0,0,1,1); tm = t; }
	if (intPlane(fpar00[3],ray, tm,t)) //bottom
	{ ob = fpar00[3]; co = vec4(1,0,1,1); tm = t; }
	if (intPlane(fpar00[4],ray, tm,t)) //back
	{ ob = fpar00[4]; co = vec4(1,1,0,1); tm = t; }
}
 
void Render(s_ray ray, out vec3 position,out vec4 ob,out vec4 co)
{
	float tm=11.0;
    float t=0.1;
 
	Render_plans(ray, position,ob,co, tm,t);
 
	t=0.1;
	if (trace(ray,tm,t))
	{
		#define epsilon 0.2
		vec3 camera_direction=vec3(0.1,0.1,1.0);
		vec3 materialDiffuse=vec3(0.2,0.4,0.2);
		float materialExponenet=256.0;
		//
		//normal
		//
		vec3 hitpoint = ray.origin + t * ray.direction;
		vec3 normal;
		normal.x=field(hitpoint+vec3(epsilon,0.0,0.0));
		normal.y=field(hitpoint+vec3(0.0,epsilon,0.0));
		normal.z=field(hitpoint+vec3(0.0,0.0,epsilon));
		normal-=field(hitpoint);
		normal=normalize(normal);
 
		//
		//light
		//
		vec3 lightsPosition[5];
		int numlight=5;
		lightsPosition[0]=vec3(2.0,-2.0,-2.0);
		lightsPosition[1]=vec3(2.0,-2.0,2.0);
		lightsPosition[2]=vec3(-2.0,-2.0,2.0);
		lightsPosition[3]=vec3(-2.0,-2.0,-2.0);
		lightsPosition[4]=vec3(2.0,2.0,-2.0);
		vec3 color=vec3(0.0,0.0,0.0);
		vec3 lightsDiffuse[5];
 
		lightsDiffuse[0]=vec3(0.0,1.0,1.0);
		lightsDiffuse[1]=vec3(1.0,0.0,1.0);
		lightsDiffuse[2]=vec3(1.0,0.0,0.0);
		lightsDiffuse[3]=vec3(0.0,0.0,1.0);
		lightsDiffuse[4]=vec3(1.0,0.5,1.0);
 
		for(int i=0;i<numlight;i++)
		{
			vec3 light_dir=normalize(lightsPosition[i]-hitpoint);
 
			//diffuse
			float diffuse=max(dot(light_dir,normal),0.0);
			color+=(lightsDiffuse[i]*diffuse).xyz*materialDiffuse.xyz;
 
			//white specular
			float specular=max(dot(reflect(-light_dir,normal),camera_direction),0.0);
			color+=pow(specular,materialExponenet);
		}
 
		ray.origin=hitpoint;
		ray.direction=normal;
		float tm=11.0;
		float t=0.1;
		vec4 coco;
 
		Render_plans(ray, position,ob,coco, tm,t);
		co=vec4(color*0.95,1.0)+vec4(coco.rgb*0.25,1.0);
	}
}
 
 
void main() 
{	
    vec2 p = -1.0 + 2.0 * gl_FragCoord.xy/ resolution.xy;
 
    ray.origin = vec3(0.0,0.0,-3.0); // ray origin
    ray.direction = normalize (vec3(p.x,p.y,-2.0)-ray.origin); // ray direction
 
	//plan (x,y,z,d)
	fpar00[0]=vec4(-1.0,0.0,0.0,-5.0); //left
	fpar00[1]=vec4(1.0,0.0,0.0,-5.0); //right
	fpar00[2]=vec4(0.0,-1.0,0.0,5.0); //top
	fpar00[3]=vec4(0.0,1.0,0.0,5.0); //bottom
	fpar00[4]=vec4(0.0,0.0,-1.0,4.6); //front
	//aabox (x,y,z,lenght)
	fpar00[5]=vec4(-8.5,-8.5,-8.5,16.0);
 
	vec4 ob;
	vec4 oc=vec4(0.0,0.0,0.0,1.0);
	vec3 position=ray.origin;
	Render(ray,position,ob,oc);
 
	gl_FragColor=oc;
}
Filed in asp.net •

chapifighter

By admin - Last updated: Jeudi, février 9, 2012

Ho ! i just found on of my end school projet (in 1998) called « chapifighter ». I recompile it and it’s still running !! It is a « open network wolfenstein » like in java . Get the source code here :)

Filed in asp.net •

another introduction to ray tracing ebook

By admin - Last updated: Vendredi, mars 25, 2011

http://www.realtimerendering.com/blog/another-introduction-to-ray-tracing/

Filed in asp.net •

RGB to Spectrum for reflectances

By admin - Last updated: Vendredi, mars 25, 2011

RGB to spectrum methode from Brian Smits.

http://www.cs.utah.edu/~bes/papers/color/

Download paper here

Filed in asp.net •

Best IES Viewer

By admin - Last updated: Samedi, mars 19, 2011

Here the best IES viewer for the best choice.


http://www.photometricviewer.com/

Filed in asp.net •

Need to remove all .svn directories ??

By admin - Last updated: Vendredi, mars 18, 2011

Some times you need to remove all .svn directories in all sub folders. It is very very slow using explorer. I found this simple shell extension.
Just import this in registry editor and use right menu on your folder to remove all .svn directories.


Download

Filed in asp.net •

using Microsoft kinect on pc !! openkinect

By admin - Last updated: Mardi, décembre 21, 2010

http://openkinect.org/wiki/Main_Page

Filed in asp.net •

Elastic: A visual theme editor and theme engine for WordPress.

By admin - Last updated: Vendredi, décembre 17, 2010

http://elastictheme.org/

Filed in asp.net •
« Older Entries

Slider by IWEBIX Webdesign

Copyright © 2010 Nicolas Vibert

Credits: Matteo Turchetto | Andreas Viklund