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"); }