private void setTransformation(Matrix4f transformation) { // Compute the modelview matrix by multiplying the camera matrix and // the transformation matrix of the object Matrix4f modelview = new Matrix4f(sceneManager.getCamera().getCameraMatrix()); modelview.mul(transformation); // Set modelview and projection matrices in shader gl.glUniformMatrix4fv( gl.glGetUniformLocation(activeShaderID, "modelview"), 1, false, transformationToFloat16(modelview), 0); gl.glUniformMatrix4fv( gl.glGetUniformLocation(activeShaderID, "projection"), 1, false, transformationToFloat16(sceneManager.getFrustum().getProjectionMatrix()), 0); int id = gl.glGetUniformLocation(activeShaderID, "camera"); if (id != -1) { Vector3f cop = sceneManager.getCamera().getCenterOfProjection(); gl.glUniform4f(id, cop.x, cop.y, cop.z, 0); } // } else // System.out.println("Could not get location of uniform variable camera"); }
public void keyPressed(KeyEvent e) { keyMove = new Matrix4f(); keyMove.setIdentity(); Vector3f keyMovement = new Vector3f(); switch (e.getKeyChar()) { case 's': keyMovement.z = -1 * scale; keyMove.setTranslation(keyMovement); break; case 'w': keyMovement.z = 1 * scale; keyMove.setTranslation(keyMovement); break; case 'a': keyMovement.x = 1 * scale; keyMove.setTranslation(keyMovement); break; case 'd': keyMovement.x = -1 * scale; keyMove.setTranslation(keyMovement); break; default: System.out.println("invalid key"); break; } }
/** Clear the framebuffer here. */ private void beginFrame() { zBuffer = new float[width][height]; mergedDisplayMatrix = new Matrix4f(viewPortMatrix); mergedDisplayMatrix.mul(sceneManager.getFrustum().getProjectionMatrix()); mergedDisplayMatrix.mul(sceneManager.getCamera().getCameraMatrix()); colorBuffer.getGraphics().clearRect(0, 0, width, height); }
public void setDirection(Vector3f direction) { Matrix4f initMat = new Matrix4f(); float angle = new Vector3f(1, 0, 0).angle(direction); if (direction.z > 0) initMat.rotY(-angle); else initMat.rotY(angle); setTransformation(initMat); }
/** * Unprojects the screen coordinates into a ray in the 3D space. It creates a point and a * direction in the object space where the ray will pass through. This can be used if the user * should be able to interact with the 3D space. * * @param x the x-coordinate * @param y the y-coordinate * @return the ray in the object space */ public Ray unproject(float x, float y) { Matrix4f staticMatrix = createMatrices(); Matrix4f inverse; Vector3f origin = new Vector3f(x, y, 1); Vector3f direction = new Vector3f(x, y, -1); inverse = new Matrix4f(staticMatrix); try { inverse.invert(); } catch (RuntimeException exc) { // Matrix not invertable, therefore no action. Log.e("UNPROJECT", "Matrix can't be inverted"); return null; } Util.transform(inverse, origin); Util.transform(inverse, direction); direction.sub(origin); direction.normalize(); return new Ray(origin, direction); }
/** * A wheel class, isn't that great? Does not move on its own, only rotate * * @param radius * @param direction * @param speed */ public Wheel(float radius, float speed) { super(new Torus(radius, radius / 4, 60, 5)); this.radius = radius; rotatePerStep.rotZ(0.01f * speed / radius); rotatePerStep.invert(); rotate.setIdentity(); }
void setDirectionVector(ServerElement element, Float x, Float y, Float z) { RigidBody rb = elementToRigidBody.get(element); rb.getOrientation(oriantation); rot.set(oriantation); directionVector.set(x, y, z); rot.transform(directionVector); }
public void position(Vector3f vec) { activate(); Matrix4f t = transform(); t.setTranslation(vec); transform(t); }
/** * Consolidated the array of transform elements into the argument matrix * * @param te The array of TransformElements */ static void getMatrix(TransformElement[] te, Matrix4f matrix) { Matrix4f m = new Matrix4f(); matrix.setIdentity(); for (int i = 0; i < te.length; i++) { te[i].getMatrix(m); matrix.mul(m); } }
public void mouseDragged(MouseEvent e) { oldMoveVector = new Vector3f(fixOldX, oldY, oldZ); oldWorldZMoveVector = new Vector3f(oldX, oldY, oldZ); // get x,y newX = e.getX() / (adjustToScreenSize / 2) - 1; // used to be (float)jframe.getWidth() newY = 1 - e.getY() / (adjustToScreenSize / 2); // used to be (float)jframe.getWidth() newZ = calculateZ(newX, newY); newMoveVector = new Vector3f(fixNewX, newY, newZ); newWorldZMoveVector = new Vector3f(newX, newY, newZ); // now calculate the Camera movement Vector3f moveAxis = new Vector3f(); // moving around this axis moveAxis.cross( oldMoveVector, newMoveVector); // TODO identify, if the axis points down or upwards => adjust the angle float moveAngle = oldMoveVector.angle(newMoveVector); // moving by this angle // special Vector including the angle AxisAngle4f moveAxisAngle = new AxisAngle4f(); moveAxisAngle.set(moveAxis, moveAngle); // calculate turning axis mouseTurn = new Matrix4f(); mouseTurn.setIdentity(); mouseTurn.set(moveAxisAngle); // the new Multiplication-Matrix // now calculate the World movement Vector3f worldMoveAxis = new Vector3f(); // moving around this axis worldMoveAxis.x = 0; worldMoveAxis.y = 0; worldMoveAxis.z = 1; float worldMoveAngle = oldWorldZMoveVector.angle(newWorldZMoveVector); // moving by this angle // adjust world Angle for turning back Vector3f worldMoveAxisTemp = new Vector3f(); worldMoveAxisTemp.cross(oldWorldZMoveVector, newWorldZMoveVector); if (worldMoveAxisTemp.z < 0) { worldMoveAngle = -worldMoveAngle; } // special Vector including the angle AxisAngle4f worldMoveAxisAngle = new AxisAngle4f(); worldMoveAxisAngle.set(worldMoveAxis, worldMoveAngle); // calculate turning axis mouseWorldTurn = new Matrix4f(); mouseWorldTurn.setIdentity(); mouseWorldTurn.set(worldMoveAxisAngle); // the new Multiplication-Matrix // override the initial starting values fixOldX = fixNewX; oldX = newX; oldY = newY; oldZ = newZ; }
/** * Creates the matrices that are used for the projection from the 3D-space onto a 2D-screen. * (Result=ViewMatrix*ProjectionMatrix*ViewportMatrix) * * @return the complete matrix */ private Matrix4f createMatrices() { Matrix4f staticMatrix = new Matrix4f(mRenderer.getViewportMatrix()); Matrix4f projMatrix = mRenderer.getSceneManager().getFrustum().getProjectionMatrix(); staticMatrix.mul(projMatrix); Matrix4f cameraMatrix = mRenderer.getSceneManager().getCamera().getCameraMatrix(); staticMatrix.mul(cameraMatrix); return staticMatrix; }
@Override public void preRender(VertexType vt, Matrix4f worldMatrix, RenderManager rm) { auxMatrix.setIdentity(); rm.getViewProjectionMatrix(auxMatrix); auxMatrix.mul(worldMatrix); RenderManager.matrixToBuffer(auxMatrix, fb); glUniformMatrix4(worldViewProj, false, fb); preRenderShortcut.preRender(vt, worldMatrix, rm); }
/** * Set a new viewport size. The render context will also need to store a viewport matrix, which * you need to reset here. */ public void setViewportSize(int width, int height) { this.width = width; this.height = height; viewPortMatrix = new Matrix4f(); viewPortMatrix.setM00(width / 2f); viewPortMatrix.setM11(height / 2f); viewPortMatrix.setM22(1 / 2f); viewPortMatrix.setColumn(3, width / 2f, height / 2f, 1 / 2f, 1); colorBuffer = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR); }
// TODO: This won't work in multiplayer public float distanceToPlayer() { Transform t = new Transform(); getMotionState().getWorldTransform(t); Matrix4f tMatrix = new Matrix4f(); t.getMatrix(tMatrix); Vector3f blockPlayer = new Vector3f(); tMatrix.get(blockPlayer); blockPlayer.sub(new Vector3f(CoreRegistry.get(LocalPlayer.class).getPosition())); return blockPlayer.length(); }
// reuse untransformPointTemp to reduce memory use and speed up void unTransformPoint(Point3i screenPt, Point3f coordPt) { if (untransformPointTemp == null) untransformPointTemp = new Point3f(); untransformPointTemp.set( screenPt.x - perspectiveOffset.x, screenPt.y - perspectiveOffset.y, screenPt.z); if (perspectiveDepth) { float inversePerspectiveFactor = 1.0f / perspectiveFactor(untransformPointTemp.z); untransformPointTemp.x *= inversePerspectiveFactor; untransformPointTemp.y *= inversePerspectiveFactor; } untransformPointTemp.z += perspectiveOffset.z; if (untransformMatrixTemp == null) untransformMatrixTemp = new Matrix4f(); untransformMatrixTemp.invert(matrixTransform); untransformMatrixTemp.transform(untransformPointTemp, coordPt); }
public float distanceToEntity(EntityRef target) { Transform t = new Transform(); getMotionState().getWorldTransform(t); Matrix4f tMatrix = new Matrix4f(); t.getMatrix(tMatrix); Vector3f blockPlayer = new Vector3f(); tMatrix.get(blockPlayer); LocationComponent loc = target.getComponent(LocationComponent.class); if (loc != null) blockPlayer.sub(loc.getWorldPosition()); else blockPlayer.sub(new Vector3f()); return blockPlayer.length(); }
private void init() { mBox = new BoundingBox(mVertexBuffers.getVertexBuffer()); t = new Matrix4f(); t.setIdentity(); mZeroVector = new Vector3f(0, 0, 0); mEpsilon = 0.001f; }
/** * Draws only the vertices of the given shape in white. Normals and indices are ignored. TODO: * negative W are possible, fix plx? * * @param shape * @param t */ private void drawDotty(Shape shape, Matrix4f t) { float[] points = null, colors = null; for (VertexElement ve : shape.getVertexData().getElements()) { switch (ve.getSemantic()) { case POSITION: points = ve.getData(); break; case COLOR: colors = ve.getData(); break; case NORMAL: // DO NOT WANT break; case TEXCOORD: // DO NOT WANT break; } } for (int i = 0; i < points.length; i += 3) { Point4f v = new Point4f(points[i], points[i + 1], points[i + 2], 1); Color3f c = new Color3f(colors[i], colors[i + 1], colors[i + 2]); t.transform(v); int x = Math.round(v.x / v.w); int y = Math.round(v.y / v.w); if (x >= 0 && y >= 0 && y < colorBuffer.getHeight() && x < colorBuffer.getWidth()) drawPointAt(x, y, c.get().getRGB()); } }
@Override public void setModelViewMatrix(Matrix4f value) { gl.uniformMatrix(getUniformLocation("matWorldView"), value); value.get(normalMatrix); normalMatrix.invert(); normalMatrix.transpose(); gl.uniformMatrix(getUniformLocation("uNormalMatrix"), normalMatrix); }
private void updateLocalTransform() { localTransform = parent.transform(); Matrix4f ms = new Matrix4f(); ms.setIdentity(); Vector3f ps = parent.scale(); ms.m00 = ps.x; ms.m11 = ps.y; ms.m22 = ps.z; localTransform.mul(ms); localTransform.invert(); localTransform.mul(transform()); }
public void updateChildTransforms() { Matrix4f pt = transform(); Matrix4f ct = new Matrix4f(); Matrix4f ms = new Matrix4f(); ms.setIdentity(); Vector3f ps = scale(); ms.m00 = ps.x; ms.m11 = ps.y; ms.m22 = ps.z; pt.mul(ms); for (GameObject c : children) { ct.mul(pt, c.localTransform); c.transform(ct, false); } }
private void setTransformation(Matrix4f transformation) { // Compute the modelview matrix by multiplying the camera matrix and // the transformation matrix of the object Matrix4f modelview = new Matrix4f(sceneManager.getCamera().getCameraMatrix()); modelview.mul(transformation); // Set modelview and projection matrices in shader gl.glUniformMatrix4fv( gl.glGetUniformLocation(activeShaderID, "modelview"), 1, false, transformationToFloat16(modelview), 0); gl.glUniformMatrix4fv( gl.glGetUniformLocation(activeShaderID, "projection"), 1, false, transformationToFloat16(sceneManager.getFrustum().getProjectionMatrix()), 0); }
public static Matrix4f convertMT4JMatrixToMatrix4f(Matrix matrix) { Matrix4f mat = new Matrix4f(); for (int i = 0; i < 4; i++) { float[] col; try { col = matrix.getColumn(i); try { mat.setColumn(i, col); } catch (Exception e) { e.printStackTrace(); } } catch (Exception e1) { // TODO Auto-generated catch block e1.printStackTrace(); } } return mat; }
public static Matrix convertMatrix4fToMT4JMatrix(Matrix4f matrix) { Matrix mat = new Matrix(); for (int i = 0; i < 4; i++) { float[] col = new float[4]; matrix.getColumn(i, col); try { mat.setColumn(i, col); } catch (Exception e) { e.printStackTrace(); } } return mat; }
public void scale(float x, float y, float z, boolean updateLocal) { activate(); // Set unit scale Matrix4 t = modelInstance.transform; Matrix4 mat_scale = new Matrix4(); Vector3 s = new Vector3(); t.getScale(s); mat_scale.scl(1 / s.x, 1 / s.y, 1 / s.z); t.mul(mat_scale); // Set target scale mat_scale.idt(); mat_scale.scl(x, y, z); t.mul(mat_scale); // Relevant bullet body update CollisionShape cs = body.getCollisionShape(); cs.setLocalScaling(new Vector3f(x, y, z)); if (body.isInWorld() && body.isStaticOrKinematicObject()) scene.world.updateSingleAabb(body); // Child propagation Vector3f ps = scale(); Matrix4f pt = transform(); Matrix4f ct = new Matrix4f(); Matrix4f ms = new Matrix4f(); ms.setIdentity(); ms.m00 = ps.x; ms.m11 = ps.y; ms.m22 = ps.z; pt.mul(ms); for (GameObject c : children) { c.scale(scale().mul(c.localScale), false); ct.mul(pt, c.localTransform); c.transform(ct, false); } if (parent != null && updateLocal) { updateLocalScale(); } }
public Vertex bake(Mesh mesh, Function<Node<?>, Matrix4f> animator) { // geometry Float totalWeight = 0f; Matrix4f t = new Matrix4f(); if (mesh.getWeightMap().get(this).isEmpty()) { t.setIdentity(); } else { for (Pair<Float, Node<Bone>> bone : mesh.getWeightMap().get(this)) { totalWeight += bone.getLeft(); Matrix4f bm = animator.apply(bone.getRight()); bm.mul(bone.getLeft()); t.add(bm); } if (Math.abs(totalWeight) > 1e-4) t.mul(1f / totalWeight); else t.setIdentity(); } // pos Vector4f pos = new Vector4f(this.pos), newPos = new Vector4f(); pos.w = 1; t.transform(pos, newPos); Vector3f rPos = new Vector3f(newPos.x / newPos.w, newPos.y / newPos.w, newPos.z / newPos.w); // normal Vector3f rNormal = null; if (this.normal != null) { Matrix3f tm = new Matrix3f(); t.getRotationScale(tm); tm.invert(); tm.transpose(); Vector3f normal = new Vector3f(this.normal); rNormal = new Vector3f(); tm.transform(normal, rNormal); rNormal.normalize(); } // texCoords TODO return new Vertex(rPos, rNormal, color, texCoords); }
public void run() { adjustToScreenSize = (float) Math.min( jframe.getWidth(), jframe.getHeight()); // used here, since you can change the screen-Size Matrix4f newTranslation = new Matrix4f(); newTranslation.setIdentity(); Matrix4f oldcTranslation = new Matrix4f(); oldcTranslation = camera.getCameraMatrix(); // world z-Axis-turn if (mouseWorldTurn != null) { newTranslation.mul(mouseWorldTurn); mouseWorldTurn.setIdentity(); } // camera x-Axis-turn if (mouseTurn != null) { newTranslation.mul(mouseTurn); mouseTurn.setIdentity(); } // camera movement if (keyMove != null) { newTranslation.mul(keyMove); keyMove.setIdentity(); } newTranslation.mul(oldcTranslation); camera.setCameraMatrix(newTranslation); // something still appears to be wrong while turning // Trigger redrawing of the render window renderPanel.getCanvas().repaint(); }
/** * Draws all triangles given in <code>indices</code> of the given shape. Ignores normals. * * @param shape that is about to be drawn * @param t accumulated transformation matrix for this shape */ private void drawTrianglesSeparately(Shape shape, Matrix4f t) { VertexData vertexData = shape.getVertexData(); Point4f[] positions = new Point4f[3]; Color3f[] colors = new Color3f[3]; Point2f[] texCoords = new Point2f[3]; int k = 0; // keeps track of triangle int[] indices = vertexData.getIndices(); for (int i = 0; i < indices.length; i++) { for (VertexElement ve : vertexData.getElements()) { Point4f p; switch (ve.getSemantic()) { case POSITION: p = getPointAt(ve.getData(), indices[i]); t.transform(p); positions[k] = p; k++; // increment k here, bc color and normal might be missing break; case COLOR: colors[k] = getColorAt(ve.getData(), indices[i]); ; break; case NORMAL: // dont care // normals[k] = getPointAt(ve, indices[i]);; break; case TEXCOORD: texCoords[k] = getTexCoordAt(ve.getData(), indices[i]); break; } } if (k == 3) { rasterizeTriangle(positions, colors, texCoords, shape.getMaterial()); k = 0; } } }
public Matrix4f computeViewMatrix( double lat, double lon, double hEllps, double az, double ha, Matrix4f mat) { if (mat == null) mat = new Matrix4f(); if (globe != null) globe.getEllipsoid().computeSurfaceTransform(lat, lon, hEllps, az, ha, mat, origin); else mat.setIdentity(); /* if (globe != null) { globe.getEllipsoid().toCartesian(lat, lon, hEllps, eye); eyeVector.set((float)(eye.x - origin.x), (float)(eye.y - origin.y), (float)(eye.z - origin.z)); } else eyeVector.set(0,0,0); if (mat == null) mat = new Matrix4f(); mat.set(eyeVector); workTrans.rotZ((float)(Math.PI/2.+lon)); mat.mul(workTrans); workTrans.rotX((float)(Math.PI/2.-lat)); mat.mul(workTrans); workTrans.rotZ((float)(-az)); mat.mul(workTrans); workTrans.rotX((float)(Math.PI/2.+ha)); mat.mul(workTrans); */ return mat; }
/** The main rendering method. You will need to implement this to draw 3D objects. */ private void draw(RenderItem renderItem) { Matrix4f t = new Matrix4f(mergedDisplayMatrix); t.mul(renderItem.getT()); drawTrianglesSeparately(renderItem.getShape(), t); // drawDotty(renderItem.getShape(), t); }