Hi Guys
I do not understand what's the difference when the dependences were retrieved from crates.io or github or local one.
Here are the 3 respective config in Cargo.toml
[dependencies]
piston = "0.27.0"
piston2d-graphics = "0.19.0"
pistoncore-glutin_window = "0.33.0"
piston2d-opengl_graphics = "0.36.0"
piston = {git = "https://github.com/PistonDevelopers/piston"}
piston2d-graphics = {git = "https://github.com/PistonDevelopers/graphics"}
pistoncore-glutin_window = {git = "https://github.com/PistonDevelopers/glutin_window"}
piston2d-opengl_graphics = {git = "https://github.com/PistonDevelopers/opengl_graphics"}
piston = {path="../piston-master"}
piston2d-graphics = {path="../graphics-master"}
pistoncore-glutin_window = {path="../glutin_window-master"}
piston2d-opengl_graphics = {path="../opengl_graphics-master"}
And the main.rs:
extern crate piston;
extern crate graphics;
extern crate glutin_window;
extern crate opengl_graphics;
use piston::WindowSettings;
use piston::event_loop::;
use piston::input::;
use glutin_window::GlutinWindow;
use opengl_graphics::{GlGraphics, OpenGL};
pub struct App {
pub gl: GlGraphics, // OpenGL drawing backend.
pub rotation: f64, // Rotation for the square.
}
impl App {
pub fn render(&mut self, args: &RenderArgs) {
use graphics::*;
const GREEN: [f32; 4] = [0.0, 1.0, 0.0, 1.0];
const RED: [f32; 4] = [1.0, 0.0, 0.0, 1.0];
let square = rectangle::square(0.0, 0.0, 50.0);
let rotation = self.rotation;
let (x, y) = ((args.width / 2) as f64, (args.height / 2) as f64);
self.gl.draw(args.viewport(), |c, gl| {
// Clear the screen.
clear(GREEN, gl);
let transform = c.transform
.trans(x, y)
.rot_rad(rotation)
.trans(-25.0, -25.0);
// Draw a box rotating around the middle of the screen.
rectangle(RED, square, transform, gl);
});
}
pub fn update(&mut self, args: &UpdateArgs) {
// Rotate 2 radians per second.
self.rotation += 2.0 * args.dt;
}
}
fn main() {
let opengl = OpenGL::V2_1;
// Create an Glutin window.
let mut window: GlutinWindow = WindowSettings::new("spinning-square", [200, 200])
.opengl(opengl)
.exit_on_esc(true)
.build()
.unwrap();
// Create a new game and run it.
let mut app = App {
gl: GlGraphics::new(opengl),
rotation: 0.0,
};
let mut events = window.events();
while let Some(e) = events.next(&mut window) {
if let Some(r) = e.render_args() {
app.render(&r);
}
if let Some(u) = e.update_args() {
app.update(&u);
}
}
}
When you try to build with dependences from crates.io, it will build successfully; whereas the rest 2 will have no luck.
I don't know why the rest 2 ways will fail, this is my first question.
And my second question is:
My purpose to build in the ways with dependences from github or local sources is: because the racer cannot show intelligent prompts for some methods or structs when I build with dependences from crates.io, I think it may due to the lacking of source files of the dependences, so I tried to build my project with source code from github or local projects instead of the crates from crates.io, in a hope to let racer show all the intelligent prompts. I don't know if I was in the wrong way or not, please give me a hand.
Much appreciated!