3d object editor

let buffer;

let cam;

const sensitivityX = 2;

const sensitivityY = 1;

const sensitivityZ = 0.1;

const scaleFactor = 100;

let logo;

let FPS = 0;

let final = [];

​

​

​

​

var preload = () => {

  logo = loadModel('logo.obj')

  textures.path = loadImage('texte.jpg');

  textures.grass = loadImage('texture.jpg');

}

​

var setup = () => {

  //buffer.debugMode();

  colours.initialize();

  for (let i in objs) {

    keys.push(objs[i].key)

  }

  if (editMode) editor.initialize();

  def = height / 2 / tan((30 * PI) / 180)

  frameRate(60)

  createCanvas(this.innerWidth, this.innerHeight)

  im = createImage(960, 540)

  buffer = createGraphics(this.screen.width / 5, this.screen.height / 5, WEBGL)

  buffer.setAttributes('antialias', "false");

  drawingContext.imageSmoothingEnabled = false;

  cam = buffer.createCamera()

  cams.initialize();

  cam.eyeY = -1

  //l(cam)

  compileObjects();

}

​

var draw = () => {

  if (settings.FPS.count == 0) {

    FPS = round(frameRate())

  }

  settings.FPS.count++;

  if (settings.FPS.count == settings.FPS.pollingRate) {

    settings.FPS.count = 0;

  }

  cams.update();

​

  clear();

  background(55)

  buffer.clear();

  buffer.background(0)

  buffer.noFill();

  buffer.stroke(255)

  if (editMode) {

    editor.update();

  }

​

​

​

​

​

​

  //buffer.plane(100)

  // buffer.beginShape();

  // buffer.vertex(0, 0, 0)

  // buffer.vertex(0, 0, 1)

  // buffer.vertex(1, 0, 0)

  // buffer.endShape();

  for (let i = 0; i < final.length; i++) {

    s3();

    if (renderQ[i].length == 2) {

      //renderQ[i][1]();

    }

    //l(textures[renderQ[i][0].key])

    buffer.noStroke();

    buffer.textureWrap(REPEAT)

    buffer.texture(textures[renderQ[i][0].key])

    buffer.model(final[i])

    e3();

  }

  if (fullscreen()) {

    image(buffer, 0, 0, this.screen.width, this.screen.height)

  } else {

    image(buffer, 0, 0, this.innerWidth, this.innerHeight)

  }

  if (editMode) {

    editor.render();

  }

  fill(255)

  text(FPS, 3, 11)

  if (editMode) {

    exitPointerLock();

  }

  if (editMode) {

    s();

    let hh = height / 2;

    let hw = width / 2;

​

    stroke(0)

    strokeWeight(4)

    line(hw - 10, hh, hw - 4, hh)

    line(hw + 10, hh, hw + 4, hh)

    line(hw, hh - 10, hw, hh - 4)

    line(hw, hh + 10, hw, hh + 4)

    stroke(0, 200, 100)

    strokeWeight(2)

    line(hw - 10, hh, hw - 4, hh)

    line(hw + 10, hh, hw + 4, hh)

    line(hw, hh - 10, hw, hh - 4)

    line(hw, hh + 10, hw, hh + 4)

    e();

  }

}

​

​

​

​

const render3 = obj => {

​

}

​

​

​

const snap = (num, roundto) => {

  return round(num/roundto)*roundto

}

​

function mouseDragged() {

​

  const deltaTheta =

    (-sensitivityX * (mouseX - pmouseX)) / scaleFactor;

  const deltaPhi =

    (sensitivityY * (mouseY - pmouseY)) / scaleFactor;

  //cam._orbit(deltaTheta, deltaPhi, 0);

}

​

function mouseWheel(event) {

  if (event.delta > 0) {

    //cam._orbit(0, 0, sensitivityZ * scaleFactor);

  } else {

    //cam._orbit(0, 0, -sensitivityZ * scaleFactor);

  }

}

​

var keyPressed = () => {

  for (let i in keybinds) {

    if (event.key == keybinds[i].bind) {

      keybinds[i].pressed = true;

      if (keybinds[i].fxn != null) {

        keybinds[i].fxn();

      }

    }

  }

  requestPointerLock();

  if (!fullscreen()) {

    fullscreen(true)

​

    resizeCanvas(this.screen.width, this.screen.height)

​

  } else {

    //exitPointerLock();

    //resizeCanvas(this.innerWidth, this.innerHeight);

​

  }

}

​

var keyReleased = () => {

  for (let i in keybinds) {

    if (event.key == keybinds[i].bind) {

      keybinds[i].pressed = false;

    }

  }

}

​

​

const compileObjects = () => {

  final = [];

  for (let i = 0; i < renderQ.length; i++) {

    let geo = renderQ[i][0].geo;

    let dx = renderQ[i][1][0];

    let dy = renderQ[i][1][1];

    let dz = renderQ[i][1][2];

    final.push(new p5.Geometry(0, 0, function createGeometry() {

      geo.forEach((x, j) => {

        let d1 = vec3(x[0][0] + dx, x[0][1] + dy, x[0][2] + dz)

        let d2 = vec3(x[1][0] + dx, x[1][1] + dy, x[1][2] + dz);

        let d3 = vec3(x[2][0] + dx, x[2][1] + dy, x[2][2] + dz)

        this.vertices.push(d1, d2, d3)

        this.faces.push([j * 3, j * 3 + 1, j * 3 + 2]);

        this.vertexNormals.push(vec3(x[3][0], x[3][1], x[3][2]), vec3(x[3][0], x[3][1], x[3][2]), vec3(x[3][0], x[3][1], x[3][2]));

        let c1 = d1.copy();

        let c2 = d2.copy();

        let c3 = d3.copy();

​

        // let n1 = vec2(tri[0].x, tri[0].z)

        // n1.normalize();

        // n1.mult(abs(tri[0].y))

        // let n2 = vec2(tri[1].x, tri[1].z)

        // n2.normalize();

        // n2.mult(abs(tri[1].y))

        // let n3 = vec2(tri[2].x, tri[2].z)

        // n3.normalize();

        // n3.mult(abs(tri[2].y))

        let tri = [...x]

        c1.x += -tri[3][0] * tri[0][1]

        c1.z += -tri[3][2] * tri[0][1]

        c2.x += -tri[3][0] * tri[1][1]

        c2.z += -tri[3][2] * tri[1][1]

        c3.x += -tri[3][0] * tri[2][1]

        c3.z += -tri[3][2] * tri[2][1]

        // c2.add(c2.y)

        // c3.add(c3.y)

        let p1 = [c1.x, c1.z]

        let p2 = [c2.x, c2.z]

        let p3 = [c3.x, c3.z]

        p1[0] /= 16

        p1[1] /= 16

        p2[0] /= 16

        p2[1] /= 16

        p3[0] /= 16

        p3[1] /= 16

​

        this.uvs.push([p1[0], p1[1]], [p2[0], p2[1]], [p3[0], p3[1]])

​

      })

      this.gid = `${i}${version}`

    }))

​

​

  }

}