public void shader1f(GL2GL3 gl, float i, String name) {
shader.use(gl);
gl.glUniform1f(gl.glGetUniformLocation(shader.getID(), name), i);
shadertess.use(gl);
gl.glUniform1f(gl.glGetUniformLocation(shadertess.getID(), name), i);
shadertess.unuse(gl);
}
/*
* Draw function - called for every frame
*/
public void onDrawFrame(GL10 glUnused) {
// Ignore the passed-in GL10 interface, and use the GLES20
// class's static methods instead.
GLES20.glClearColor(.0f, .0f, .0f, 1.0f);
GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
GLES20.glUseProgram(0);
// the current shader
Shader shader = _shaders[this._currentShader]; // PROBLEM!
int program = shader.get_program();
// Start using the shader
GLES20.glUseProgram(program);
checkGlError("glUseProgram");
setLight(program);
drawCar(program, new float[] {0.0f, 5.0f, 20.0f});
drawCar2(program, new float[] {-10.0f, 5.0f, 10.0f});
drawCar2(program, new float[] {-5.0f, 5.0f, -10.0f});
drawCar2(program, new float[] {10.0f, 5.0f, 0.0f});
drawCar2(program, new float[] {50.0f, 5.0f, 15.0f});
drawRoad(program);
// eye position
GLES20.glUniform3fv(
GLES20.glGetUniformLocation(program, "eyePos") /*shader.eyeHandle*/, 1, eyePos, 0);
}
public void setShadowmapShaderTexture(GL2GL3 gl, TexBindSet tbs, String texname) {
shadowmapshader.use(gl);
gl.glUniform1i(gl.glGetUniformLocation(shadowmapshader.getID(), texname), tbs.texunit);
shadowmapshadertess.use(gl);
gl.glUniform1i(gl.glGetUniformLocation(shadowmapshadertess.getID(), texname), tbs.texunit);
shadowmapshadertess.unuse(gl);
}
public void setShadowmapShader1i(GL2GL3 gl, int i, String name) {
shadowmapshader.use(gl);
gl.glUniform1i(gl.glGetUniformLocation(shadowmapshader.getID(), name), i);
shadowmapshadertess.use(gl);
gl.glUniform1i(gl.glGetUniformLocation(shadowmapshadertess.getID(), name), i);
shadowmapshadertess.unuse(gl);
}
public void init(GLAutoDrawable drawable) {
drawable.setGL(new DebugGL2(drawable.getGL().getGL2()));
final GL2 gl = drawable.getGL().getGL2();
// drawable.getGL().getGL2();
gl.glViewport(0, 0, SCREENW, SCREENH);
// Clear color buffer with black
// gl.glClearColor(1.0f, 0.5f, 1.0f, 1.0f);
gl.glClearColor(.0f, .0f, .0f, 1.0f);
gl.glClearDepth(1.0f);
gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
gl.glEnable(GL2.GL_DEPTH_TEST);
gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1);
gl.glCreateShader(GL2GL3.GL_VERTEX_SHADER);
shader.init(gl);
int programName = shader.getID();
gl.glBindAttribLocation(programName, Object3D.VERTEXPOSITION, "inposition");
gl.glBindAttribLocation(programName, Object3D.VERTEXCOLOR, "incolor");
gl.glBindAttribLocation(programName, Object3D.VERTEXNORMAL, "innormal");
gl.glBindAttribLocation(programName, Object3D.VERTEXTEXCOORD0, "intexcoord0");
shader.link(gl);
uniformMat = gl.glGetUniformLocation(programName, "mat");
uniformLight = gl.glGetUniformLocation(programName, "lightdir");
gl.glUseProgram(programName);
gl.glUniform3f(uniformLight, 0f, 10f, -10f);
obj.init(gl, mats, programName);
gl.glUseProgram(0);
}
public void link() {
for (Shader s : shaders) {
if (null != s && s.shader == -1) {
s.compile();
}
}
int newProgram = linkProgram(shaders);
if (program != -1) {
glDeleteProgram(program);
program = -1;
}
this.uniforms.clear();
this.attributes.clear();
program = newProgram;
if (program == -1) {
throw new IllegalStateException("Link failure");
}
int count = glGetProgrami(program, GL_ACTIVE_UNIFORMS);
for (int i = 0; i < count; ++i) {
String name = glGetActiveUniform(program, i, 256);
int location = glGetUniformLocation(program, name);
this.uniforms.put(name, location);
}
count = glGetProgrami(program, GL_ACTIVE_ATTRIBUTES);
for (int i = 0; i < count; ++i) {
String name = glGetActiveAttrib(program, i, 256);
int location = glGetAttribLocation(program, name);
this.attributes.put(name, location);
}
}
public void render() {
RenderUtil.setClearColor(Transform.getCamera().getPos().div(2048f).abs());
_shader.bind();
_shader.updateUniforms(
_transform.getTransformation(), _transform.getProjectedTransformation(), _material);
_mesh.draw();
}
public void updateligths(GL2GL3 gl, Shader shader) {
updatelights(
gl,
gl.glGetUniformLocation(shader.getID(), "lightsview"),
gl.glGetUniformLocation(shader.getID(), "lightsproj"),
gl.glGetUniformLocation(shader.getID(), "lightscolor"),
gl.glGetUniformLocation(shader.getID(), "lightsattr"),
gl.glGetUniformLocation(shader.getID(), "lightcount_real_virtual"));
}
public void renderingToWindow(GL2GL3 gl, boolean show) {
shadertess.use(gl);
updateligths(gl, shadertess);
scenetess((GL3) gl, shadertess, false);
shader.use(gl);
updateligths(gl, shader);
scene(gl, shader, show);
Shader.unuse(gl);
}
public void shader1i(GL2GL3 gl, int i, String name) {
shader.use(gl);
gl.glUniform1i(gl.glGetUniformLocation(shader.getID(), name), i);
// gl.glUniform(new GLUniformData(name, i));
shadertess.use(gl);
gl.glUniform1i(gl.glGetUniformLocation(shadertess.getID(), name), i);
// GLUniformData tmp = new GLUniformData(name, i);
// tmp.setLocation(gl.glGetUniformLocation(shadertess.getID(), name));
// gl.glUniform(tmp);
shadertess.unuse(gl);
}
public void init(GL2GL3 gl, Shader shader, Shader shadertess) {
this.shader = shader;
shader.use(gl);
uniformview = gl.glGetUniformLocation(shader.getID(), "view");
uniformproj = gl.glGetUniformLocation(shader.getID(), "proj");
this.shadertess = shadertess;
shadertess.use(gl);
uniformviewtess = gl.glGetUniformLocation(shadertess.getID(), "view");
uniformprojtess = gl.glGetUniformLocation(shadertess.getID(), "proj");
shadertess.unuse(gl);
}
@Override
protected void updateFragmentSource(String src) {
List<String> vars = Arrays.asList(ChunksFragmentShader.LOGDEPTHBUF_PAR);
List<String> main = Arrays.asList(ChunksFragmentShader.LOGDEPTHBUF);
super.updateFragmentSource(updateShaderSource(src, vars, main));
}
public static int linkProgram(Shader... shaders) {
int newProgram = glCreateProgram();
for (Shader s : shaders) {
if (null != s) {
s.attach(newProgram);
}
}
glLinkProgram(newProgram);
int linkResult = glGetProgrami(newProgram, GL_LINK_STATUS);
if (GL_TRUE != linkResult) {
String log = getLog(newProgram);
LOG.warn("Link failed: " + log);
glDeleteProgram(newProgram);
throw new RuntimeException(log);
}
return newProgram;
}
@Override
public void setSelectedItem(Object anObject) {
super.setSelectedItem(anObject);
shader = Shader.valueOf(anObject.toString());
recalc();
frame.recalc();
frame.repaint();
}
public void updateModelMatrix(GL2GL3 gl, Shader shader, PMVMatrix model) {
model.update();
// if(gl.glGetUniformLocation(shader.getID(), "model") == -1)
// System.out.println("uniform model error");
gl.glUniformMatrix4fv(
gl.glGetUniformLocation(shader.getID(), "model"),
1,
false,
model.glGetMatrixf(GL2.GL_MODELVIEW));
}
public void renderingToFBO(
GL2GL3 gl, FBO fbo, int offsetx, int offsety, int width, int height, boolean show) {
shader.use(gl);
fbo.bind(gl);
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
gl.glViewport(offsetx, offsety, width, height);
shader.use(gl);
updateligths(gl, shader);
scene(gl, shader, show);
shadertess.use(gl);
updateligths(gl, shadertess);
scenetess((GL3) gl, shadertess);
shadertess.unuse(gl);
fbo.unbind(gl);
gl.glFlush();
}
public void ShadowMap(GL2GL3 gl, boolean show) {
smapfbo.bind(gl);
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
gl.glViewport(0, 0, smapwidth, smapheight);
shadowmapshadertess.use(gl);
gl.glUniform1i(gl.glGetUniformLocation(shadowmapshadertess.getID(), "stage"), 0);
smapupdatelightstess(gl);
scenetess((GL4) gl, shadowmapshadertess);
shadowmapshader.use(gl);
gl.glUniform1i(gl.glGetUniformLocation(shadowmapshader.getID(), "stage"), 0);
smapupdatelights(gl);
scene(gl, shadowmapshader, show);
gl.glFlush();
smapfbo.unbind(gl);
Shader.unuse(gl);
}
public void end() {
sorter.sort(camera, renderables);
context.begin();
Shader currentShader = null;
for (int i = 0; i < renderables.size; i++) {
final Renderable renderable = renderables.get(i);
if (currentShader != renderable.shader) {
if (currentShader != null) currentShader.end();
currentShader = renderable.shader;
currentShader.begin(camera, context);
}
currentShader.render(renderable);
}
if (currentShader != null) currentShader.end();
context.end();
renderablesPool.freeAll(reuseableRenderables);
reuseableRenderables.clear();
renderables.clear();
camera = null;
}
public void setTessLevel(GL2GL3 gl, int level) {
shadowmapshadertess.use(gl);
gl.glUniform1i(gl.glGetUniformLocation(shadowmapshadertess.getID(), "tesslevel"), level);
shadowmapshadertess.unuse(gl);
shadertess.use(gl);
gl.glUniform1i(gl.glGetUniformLocation(shadertess.getID(), "tesslevel"), level);
shadertess.unuse(gl);
}
public void display(GLAutoDrawable drawable) {
final GL2 gl = drawable.getGL().getGL2();
gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
mats.glMatrixMode(GL2.GL_MODELVIEW);
mats.glLoadIdentity();
mats.glTranslatef(0f, 0f, -2.0f);
// t = t+0.5f;
t = 40f;
mats.glRotatef(t, 0f, 1f, 0f);
mats.glMatrixMode(GL2.GL_PROJECTION);
mats.glLoadIdentity();
mats.glFrustumf(-1f, 1f, -1f, 1f, 1f, 100f);
mats.update();
gl.glUseProgram(shader.getID());
gl.glUniformMatrix4fv(uniformMat, 3, false, mats.glGetPMvMviMatrixf());
obj.display(gl, mats);
gl.glFlush();
gl.glUseProgram(0);
}
public void init(GL2GL3 gl) {
timer.init(gl);
smapfbo = new FBO(gl);
texviewer = new TexViewer();
texviewer.init(gl);
fxaa = new Filter("resources/ShaderSource/FXAA/vert.c", "resources/ShaderSource/FXAA/frag.c");
fxaa.init(gl);
// String filepath = "/home/michael/zheng/Programs/WeatherData/2009100718/";
String filepath = "/home/michael/zheng/Programs/WeatherData/2009100818/";
// String filepath = "/home/michael/zheng/Programs/WeatherData/2008061418/";
// initTestData(gl);
scene = new Scene1();
scene.initShadowmap(gl, 2, SHADOWMAPWIDTH, SHADOWMAPHEIGHT);
for (int i = 0; i < scene.lightCount(); i++) {
scene.lights.get(i).init(gl);
// float angle = 2 * (float)Math.PI * i / (scene.lightCount() - 1);
// //scene.lights.get(i).lookat(3, 3, i + 1, 0, 0, 0, 0, 1, 0);
// scene.lights.get(i).lookat(6*(float)Math.sin(angle), 6*(float)Math.cos(angle), 8,
// 0, 0, 0, 0, 1, 0);
// scene.lights.get(i).perspectivef(120f, 1, 0.1f, 50f);
}
scene.lights.get(0).lookatd(4, 4, 10, 0, 0, 0, 0, 1, 0);
// scene.lights.get(0).lookatd(0, 0, 50, 0, 0, 0, 0, 1, 0);
scene.lights.get(0).orthof(-4, 4, -4, 4, 0, 60);
scene.lights.get(0).setattr(0, 1);
scene.lights.get(0).setintensity(1.25);
// scene.lights.get(2).lookatd(4, 4, 10, 0, 0, 0, 0, 1, 0);
// scene.lights.get(2).orthof(-5, 5, -5, 5, 0, 30);
scene.lights.get(1).lookatd(4, -4, 10, 0, 0, 0, 0, 1, 0);
scene.lights.get(1).orthof(-4, 4, -4, 4, 0, 100);
// scene.lights.get(2).lookatd(0, 0, 50, 0, 0, 0, 0, 1, 0);
// scene.lights.get(2).orthof(-5, 5, -5, 5, 0, 100);
shader =
new Shader(
"resources/ShaderSource/BaseShaders/SimpleShader/vert.c",
null,
null,
null,
"resources/ShaderSource/BaseShaders/SimpleShader/frag.c");
shader.init(gl);
shadowmapping =
new Shader(
"resources/ShaderSource/ShadowMapping/vert.c",
null,
null,
"resources/ShaderSource/ShadowMapping/geom.c",
"resources/ShaderSource/ShadowMapping/fragsimple.c");
shadowmapping.init(gl);
shadowmapping.use(gl);
// tess evalシェーダーはシャドウマップのものを使う
shadowmappingtess =
new Shader(
"resources/ShaderSource/ShadowMapping/vert.c",
"resources/ShaderSource/ShadowMapping/ctrl.c",
"resources/ShaderSource/BaseShaders/Shadowmap/eval.c",
"resources/ShaderSource/ShadowMapping/geom.c",
"resources/ShaderSource/ShadowMapping/frag.c");
shadowmappingtess.init(gl);
tex =
new Tex2D(
GL2.GL_RGBA,
GL2.GL_RGBA,
GL2.GL_FLOAT,
1024,
1024,
GL2.GL_LINEAR,
GL2.GL_REPEAT,
GL2.GL_REPEAT,
null,
"testimage");
tex.init(gl);
tbs = new TexBindSet(tex);
tbs.bind(gl);
// scene.updateligths(gl, shadowmapping);
// scene.lookat(0, 0, 30, 0, 0, 0, 0, 1, 0);
// scene.orthof(proj[0], proj[1], proj[2], proj[3], 0, 100);
// initの場所はあとで調整
scene.init(gl, shadowmapping, shadowmappingtess);
// 円柱オフ
scene.shader1i(gl, 0, "offheight");
fbo = new FBO(gl);
fbo.attachTexture(gl, tbs);
fbo.attachDepthRBO(gl, 1024, 1024);
// */
initSceneOrganizer(gl);
Ctrlpanel.currentSO = currentSO;
}
/** @author Szymon */
public class Lamp extends AbstractTransformChangeNotifier {
double ks = 0.1, kd = 1;
double m = 1.2;
int d0 = 0;
enum Shader {
FLAT,
GOURAUD_TRI,
GOURAUD_RECT,
PHONG
}
private ComboBoxModel model =
new DefaultComboBoxModel(Shader.values()) {
@Override
public void setSelectedItem(Object anObject) {
super.setSelectedItem(anObject);
shader = Shader.valueOf(anObject.toString());
recalc();
frame.recalc();
frame.repaint();
}
};
protected Shader shader = Shader.FLAT;
private Matrix1x4 viewer;
private static final double[][] CORNERS = {{0, -2 * Brick.SIZE, -2 * Brick.SIZE, 1}};
public Lamp() {
super(CORNERS);
recalc();
}
public int calculateBrithness(Matrix1x4 point, Vector vector) {
Vector e = new Vector(point, viewer).normalize();
Vector l = new Vector(point, corners3D[0]);
double len = l.length();
double brightness = (kd * vector.cosNorm(l) + ks * Math.pow(e.cosNorm(l), m)) / (len * len);
brightness *= 256 * 256;
if (brightness < 0) {
brightness = 0;
}
return (int) brightness;
}
public int applyBrigthness(int color, int brightness) {
int checkMask = 0x01000000;
if ((color & checkMask) != 0 || (color & 0xff000000) == 0) {
return color;
}
int mask = 0xff;
int tmp;
for (int k = 0; k < 19; k += 8) {
tmp = ((color & mask) >> k) + 1;
tmp *= brightness;
tmp >>>= 8;
if (tmp > 255) {
tmp = 255;
} else if (tmp < 0) {
tmp = 0;
}
color = (color & ~mask) | (tmp << k);
mask <<= 8;
}
return color | checkMask;
}
public static void sortIndexes2D(int[] indexes, int[][] corners) {
for (int i = 0; i < indexes.length; ++i) {
for (int k = i + 1; k < indexes.length; ++k) {
int[] ci = corners[indexes[i]];
int[] ck = corners[indexes[k]];
if (ck[1] < ci[1] || (ck[1] == ci[1] && ck[0] < ci[0])) {
int tmp = indexes[k];
indexes[k] = indexes[i];
indexes[i] = tmp;
}
}
}
}
public static void testSortedIndexes(int[] indexes, int[][] corners) {
int a = corners[indexes[0]][1];
int b = corners[indexes[1]][1];
int c = corners[indexes[2]][1];
if (a > b || b > c || a > c) {
System.err.println("Zle sorotwanie indeksow: " + a + " " + b + " " + c);
}
}
public static double safeDivide(double a, double b) {
try {
return a / b;
} catch (ArithmeticException e) {
System.err.println("Div 0");
return Double.POSITIVE_INFINITY;
}
}
private void gradientLine(int[] buff, int offset, int steps, int v1, int v2) {
int end = offset + steps;
double gradientStep = safeDivide(v2 - v1, Math.abs(steps) + 1);
double gradVal = v1;
int tmp;
if (steps > 0) {
++end;
for (; offset <= end; ++offset) {
try {
buff[offset] = applyBrigthness(buff[offset], (int) gradVal);
} catch (ArrayIndexOutOfBoundsException e) {
}
gradVal += gradientStep;
}
} else if (steps < 0) {
++offset;
for (; offset >= end; --offset) {
try {
buff[offset] = applyBrigthness(buff[offset], (int) gradVal);
} catch (ArrayIndexOutOfBoundsException e) {
}
gradVal += gradientStep;
}
} else {
try {
buff[offset] = applyBrigthness(buff[offset], v1);
} catch (ArrayIndexOutOfBoundsException e) {
}
}
}
private void gradientLine(
int[] buff, int offset, int steps, Matrix1x4 p1, Matrix1x4 p2, Vector wallNormVec) {
int end = offset + steps;
Vector vectorStep = stepVector(p1, p2, Math.abs(steps) + 1);
Matrix1x4 tmpPoint = p1.clone();
if (steps > 0) {
++end;
for (; offset <= end; ++offset) {
try {
buff[offset] = applyBrigthness(buff[offset], calculateBrithness(tmpPoint, wallNormVec));
} catch (ArrayIndexOutOfBoundsException e) {
}
tmpPoint.accumulate(vectorStep);
}
} else if (steps < 0) {
++offset;
for (; offset >= end; --offset) {
try {
buff[offset] = applyBrigthness(buff[offset], calculateBrithness(tmpPoint, wallNormVec));
} catch (ArrayIndexOutOfBoundsException e) {
}
tmpPoint.accumulate(vectorStep);
}
}
}
public static int diffY(int i1, int i2, int[] indexes, int[][] corners) {
return corners[indexes[i1]][1] - corners[indexes[i2]][1];
}
public static double stepX(int i1, int i2, int[] indexes, int[][] corners) {
return safeDivide(
corners[indexes[i1]][0] - corners[indexes[i2]][0], diffY(i1, i2, indexes, corners));
}
public static double stepB(int i1, int i2, int[] indexes, int[] brightnesses, int[][] corners) {
return safeDivide(
brightnesses[indexes[i1]] - brightnesses[indexes[i2]], diffY(i1, i2, indexes, corners));
}
public static Vector stepVector(Matrix1x4 from, Matrix1x4 to, double steps) {
Vector v = new Vector(from, to);
steps = Math.abs(steps);
for (int i = 0; i < 4; ++i) {
v.data[i] /= steps;
}
return v;
}
public static Vector stepVector(
int i1, int i2, int[] indexes, Matrix1x4[] corners3D, int[][] corners2D) {
double steps = diffY(i1, i2, indexes, corners2D);
return stepVector(corners3D[indexes[i2]], corners3D[indexes[i1]], steps);
}
/**
* @param buff
* @param width buff's row width
* @param indexes sorted indexes
* @param wall.corners2D unsorted corners
* @param brightnesses unsorted brightnesses
*/
private void gouraudTriangle(
Wall wall, int offset, int width, int[] indexes, int[] brightnesses) {
int diffY_0_1 = diffY(1, 0, indexes, wall.corners2D);
int diffY_0_2 = diffY(2, 0, indexes, wall.corners2D);
double bStep0_1 = stepB(1, 0, indexes, brightnesses, wall.corners2D);
double bStep0_2 = stepB(2, 0, indexes, brightnesses, wall.corners2D);
double bStep1_2 = stepB(2, 1, indexes, brightnesses, wall.corners2D);
double xStep0_1 = stepX(1, 0, indexes, wall.corners2D);
double xStep0_2 = stepX(2, 0, indexes, wall.corners2D);
double xStep1_2 = stepX(2, 1, indexes, wall.corners2D);
double x1 = 0, x2 = 0;
double b1, b2;
b1 = b2 = brightnesses[indexes[0]];
for (int y = 0; y < diffY_0_1; ++y) {
gradientLine(wall.buff, (int) (offset + x1), (int) (x2 - x1 + 0.5), (int) b1, (int) b2);
x1 += xStep0_1;
b1 += bStep0_1;
x2 += xStep0_2;
b2 += bStep0_2;
offset += width;
}
b1 = brightnesses[indexes[1]];
if (diffY_0_1 == 0) {
x1 += width;
}
for (int y = diffY_0_1; y < diffY_0_2; ++y) {
gradientLine(wall.buff, (int) (offset + x1), (int) (x2 - x1 + 0.5), (int) b1, (int) b2);
x1 += xStep1_2;
b1 += bStep1_2;
x2 += xStep0_2;
b2 += bStep0_2;
offset += width;
}
}
private void phongTriangle(Wall wall, int offset, int width, int[] indexes) {
int diffY_0_1 = diffY(1, 0, indexes, wall.corners2D);
int diffY_0_2 = diffY(2, 0, indexes, wall.corners2D);
double xStep_0_1 = stepX(1, 0, indexes, wall.corners2D);
double xStep_0_2 = stepX(2, 0, indexes, wall.corners2D);
double xStep_1_2 = stepX(2, 1, indexes, wall.corners2D);
Vector vStep_0_1 = stepVector(1, 0, indexes, wall.corners3D, wall.corners2D);
Vector vStep_0_2 = stepVector(2, 0, indexes, wall.corners3D, wall.corners2D);
Vector vStep_1_2 = stepVector(2, 1, indexes, wall.corners3D, wall.corners2D);
double x1 = 0, x2 = 0;
Matrix1x4 p1 = wall.corners3D[indexes[0]].clone();
Matrix1x4 p2 = wall.corners3D[indexes[0]].clone();
for (int y = 0; y < diffY_0_1; ++y) {
gradientLine(wall.buff, (int) (offset + x1), (int) (x2 - x1 + 0.5), p1, p2, wall.vector);
x1 += xStep_0_1;
p1.accumulate(vStep_0_1);
x2 += xStep_0_2;
p2.accumulate(vStep_0_2);
offset += width;
}
p1 = wall.corners3D[indexes[1]].clone();
if (diffY_0_1 == 0) {
x1 += width;
}
for (int y = diffY_0_1; y < diffY_0_2; ++y) {
gradientLine(wall.buff, (int) (offset + x1), (int) (x2 - x1 + 0.5), p1, p2, wall.vector);
x1 += xStep_1_2;
p1.accumulate(vStep_1_2);
x2 += xStep_0_2;
p2.accumulate(vStep_0_2);
offset += width;
}
}
public static boolean sameRow(int x1, int x2, int width) {
boolean val = (x1 / width) == (x2 / width);
if (!val) {
System.err.print("ROWS: X1: " + x1 / width + " ");
System.err.println("X2: " + x2 / width + " " + val);
}
return val;
}
private void enlightTriangles(Wall wall, int width) {
int brights[] = new int[4];
for (int i = 0; i < 4; ++i) {
brights[i] = calculateBrithness(wall.corners3D[i], wall.vector);
}
// podzial na 2 trojkaty
int[][] triangleIndexes = {{0, 1, 2}, {0, 2, 3}};
Polygon p = new Polygon();
for (int[] corner : wall.corners2D) {
p.addPoint(corner[0], corner[1]);
}
int minX = p.getBounds().x;
int minY = p.getBounds().y;
for (int[] indexes : triangleIndexes) {
sortIndexes2D(indexes, wall.corners2D);
int xoffset = wall.corners2D[indexes[0]][0] - minX;
int yoffset = wall.corners2D[indexes[0]][1] - minY;
int offset = xoffset + yoffset * width;
if (shader == Shader.PHONG) {
phongTriangle(wall, offset, width, indexes);
} else {
gouraudTriangle(wall, offset, width, indexes, brights);
}
}
}
/**
* Niedokonczona implementacja usredniania Gourouda dla calego czworokata
*
* @param wall
* @param width
*/
private void gouraudRectangle(Wall wall, int width) {
int brights[] = new int[4];
for (int i = 0; i < 4; ++i) {
brights[i] = calculateBrithness(wall.corners3D[i], wall.vector);
}
int[] indexes = {0, 1, 2, 3};
sortIndexes2D(indexes, wall.corners2D);
Polygon p = new Polygon();
for (int[] corner : wall.corners2D) {
p.addPoint(corner[0], corner[1]);
}
int xoffset = wall.corners2D[indexes[0]][0] - p.getBounds().x;
int yoffset = wall.corners2D[indexes[0]][1] - p.getBounds().y;
int offset = xoffset + (yoffset) * width;
int diffY_0_1 = diffY(1, 0, indexes, wall.corners2D);
int diffY_1_2 = diffY(2, 1, indexes, wall.corners2D);
int diffY_2_3 = diffY(3, 2, indexes, wall.corners2D);
double stepX_0_1 = stepX(1, 0, indexes, wall.corners2D);
double stepX_1_3 = stepX(3, 1, indexes, wall.corners2D);
double stepX_0_2 = stepX(2, 0, indexes, wall.corners2D);
double stepX_2_3 = stepX(3, 2, indexes, wall.corners2D);
double stepB_0_1 = stepB(1, 0, indexes, brights, wall.corners2D);
double stepB_1_3 = stepB(3, 1, indexes, brights, wall.corners2D);
double stepB_0_2 = stepB(2, 0, indexes, brights, wall.corners2D);
double stepB_2_3 = stepB(3, 2, indexes, brights, wall.corners2D);
double x1 = 0;
double x2 = 0;
double b1;
double b2;
b1 = b2 = brights[indexes[0]];
int y;
for (y = 0; y < diffY_0_1; ++y) {
gradientLine(wall.buff, (int) (offset + x1), (int) (x2 - x1 + 0.5), (int) b1, (int) b2);
x1 += stepX_0_2;
b1 += stepB_0_2;
x2 += stepX_0_1;
b2 += stepB_0_1;
offset += width;
}
if (diffY_0_1 == 0) {
x2 = width;
}
for (y = 0; y < diffY_1_2; ++y) {
gradientLine(wall.buff, (int) (offset + x1), (int) (x2 - x1 + 0.5), (int) b1, (int) b2);
x1 += stepX_0_2;
b1 += stepB_0_2;
x2 += stepX_1_3;
b2 += stepB_1_3;
offset += width;
}
for (y = 0; y < diffY_2_3; ++y) {
gradientLine(wall.buff, (int) (offset + x1), (int) (x2 - x1 + 0.5), (int) b1, (int) b2);
x1 += stepX_2_3;
b1 += stepB_2_3;
x2 += stepX_1_3;
b2 += stepB_1_3;
offset += width;
}
}
/**
* @param wall
* @return true if wall is enlighten at all
*/
public boolean enlight(Wall wall, Matrix1x4 viewer, int width, int height) {
this.viewer = viewer;
switch (shader) {
case GOURAUD_TRI:
case PHONG:
enlightTriangles(wall, width);
break;
case GOURAUD_RECT:
gouraudRectangle(wall, width);
break;
case FLAT:
default:
// obliczanie sredniego punktu:
Matrix1x4 point = new Matrix1x4(0, 0, 0, 0);
for (Matrix1x4 m : wall.corners3D) {
for (int i = 0; i < 4; ++i) {
point.data[i] += m.data[i];
}
}
for (int i = 0; i < 4; ++i) {
point.data[i] /= 4;
}
int bright = calculateBrithness(point, wall.vector);
int size = width * height;
for (int i = 0; i < size; ++i) {
wall.buff[i] = applyBrigthness(wall.buff[i], bright);
}
break;
}
return true;
}
public void recalcThis() {}
@Override
public void paint(Graphics2D g, int width, int height) {
g.setColor(Color.YELLOW);
g.fillOval(corners2D[0][0] + width / 2 - 3, corners2D[0][1] + height / 2 - 3, 6, 6);
}
// reszta to juz tylko gettery i settery
public ComboBoxModel getModel() {
return model;
}
public int getD0() {
return d0;
}
public void setD0(int d0) {
this.d0 = d0;
}
public double getKd() {
return kd;
}
public void setKd(double kd) {
this.kd = kd;
}
public double getKs() {
return ks;
}
public void setKs(double ks) {
this.ks = ks;
}
public double getM() {
return m;
}
public void setM(double m) {
this.m = m;
}
protected BrickFrame frame;
public BrickFrame getFrame() {
return frame;
}
public void setFrame(BrickFrame frame) {
this.frame = frame;
}
}
public void render() {
Shader shader = Game.getLevel().getShader();
shader.updateUniforms(
transform.getTransformation(), transform.getProjectedTransformation(), material);
mesh.draw();
}
public void updatePVMatrixtess(GL2GL3 gl) {
shadertess.use(gl);
gl.glUniformMatrix4fv(uniformviewtess, 1, false, pvmat.glGetMatrixf(GL2.GL_MODELVIEW));
gl.glUniformMatrix4fv(uniformprojtess, 1, false, pvmat.glGetMatrixf(GL2.GL_PROJECTION));
Shader.unuse(gl);
}
public void initShadowmap(GL2GL3 gl, int lightcount, int width, int height) {
initLight(lightcount);
Ctrlpanel.getInstance().addLightCtrl(realLightcount, this);
smapwidth = width;
smapheight = height;
Tex2DArray shadowmap =
new Tex2DArray(
GL2.GL_RGB16,
GL2.GL_RGB,
GL.GL_FLOAT,
smapwidth,
smapheight,
realLightcount,
GL.GL_LINEAR,
"shadowmap");
Tex2DArray shadowmapdepth =
new Tex2DArray(
GL2.GL_DEPTH_COMPONENT,
GL2.GL_DEPTH_COMPONENT,
GL.GL_FLOAT,
smapwidth,
smapheight,
realLightcount,
GL.GL_LINEAR,
"shadowmapdepth");
shadowmap.init(gl);
shadowmapdepth.init(gl);
shadowmapB = tum.bind(gl, shadowmap);
smapfbo = new FBO(gl);
smapfbo.attachTexture(gl, shadowmapB);
smapfbo.attachDepth(gl, shadowmapdepth);
/*シャドウマップ*/
shadowmapshader =
new Shader(
"resources/ShaderSource/BaseShaders/Shadowmap/vertsimple.c",
null,
null,
smapgsrc,
smapfsrc);
shadowmapshader.init(gl);
shadowmapshader.use(gl);
uniformlightsview = gl.glGetUniformLocation(shadowmapshader.getID(), "lightsview");
uniformlightsproj = gl.glGetUniformLocation(shadowmapshader.getID(), "lightsproj");
uniformlightscolor = gl.glGetUniformLocation(shadowmapshader.getID(), "lightscolor");
uniformlightsattr = gl.glGetUniformLocation(shadowmapshader.getID(), "lightsattr");
uniformlightcount = gl.glGetUniformLocation(shadowmapshader.getID(), "lightcount_real_virtual");
/*シャドウマップテッセレーション*/
shadowmapshadertess = new Shader(smapvsrc, smapcsrc, smapesrc, smapgsrc, smapfsrc);
shadowmapshadertess.init(gl);
shadowmapshadertess.use(gl);
uniformlightsviewtess = gl.glGetUniformLocation(shadowmapshadertess.getID(), "lightsview");
uniformlightsprojtess = gl.glGetUniformLocation(shadowmapshadertess.getID(), "lightsproj");
uniformlightscolortess = gl.glGetUniformLocation(shadowmapshadertess.getID(), "lightscolor");
uniformlightsattrtess = gl.glGetUniformLocation(shadowmapshader.getID(), "lightsattr");
uniformlightcounttess =
gl.glGetUniformLocation(shadowmapshadertess.getID(), "lightcount_real_virtual");
}
