Skocz do zawartości


Wahadło


7 odpowiedzi w tym temacie

#1 bazer

    Nowy na forum

  • Użytkownicy
  • 1 Postów:

Napisano nie, 05 gru 2010 - 14:06

Witam jestem początkującym programistą i mam problem, otórz napisałem w Visual Studio program wahadła a dokładnie jego model i chce je teraz wprowadzić w ruch żeby poruszało się na boki jak wahadło zegara. Próbowałem z alfa+delta_ alfa ale mi to nie wychodzi czy ktoś może mi pomóc. Podspodem zamieszczam kod żródłowy.


#include <windows.h>

#include "glut.h"


void prostopadloscian()
{
glBegin(GL_QUADS);
glColor3f(0.0, 0.0, 0.0);
glVertex3f( 0.0, 0.0, 0.0);
glVertex3f( 0.0, 1.0, 0.0);
glVertex3f( 0.0, 1.0, 1.0);
glVertex3f( 0.0, 0.0, 1.0);


glColor3f(1.0, 1.0, 0.0);
glVertex3f( 1.0, 0.0, 1.0);
glVertex3f( 1.0, 0.0, 0.0);
glVertex3f( 1.0, 1.0, 0.0);
glVertex3f( 1.0, 1.0, 1.0);



glColor3f(1.0, 0.0, 0.0);
glVertex3f( 0.0, 0.0, 0.0);
glVertex3f( 1.0, 0.0, 0.0);
glVertex3f( 1.0, 1.0, 0.0);
glVertex3f( 0.0, 1.0, 0.0);

glColor3f(0.0, 0.0, 0.0);
glVertex3f( 0.0, 0.0, 1.0);
glVertex3f( 1.0, 0.0, 1.0);
glVertex3f( 1.0, 1.0, 1.0);
glVertex3f( 0.0, 1.0, 1.0);


glColor3f(1.0, 1.0, 0.0);
glVertex3f( 0.0, 0.0, 0.0);
glVertex3f( 0.0, 0.0, 1.0);
glVertex3f( 1.0, 0.0, 1.0);
glVertex3f( 1.0, 0.0, 0.0);

glColor3f(0.0, 0.0, 0.0);
glVertex3f( 0.0, 0.0, 0.0);
glVertex3f( 0.0, 1.0, 1.0);
glVertex3f( 1.0, 1.0, 1.0);
glVertex3f( 1.0, 1.0, 0.0);

glEnd();
}


void uchwyt()
{
glPushMatrix();
glTranslatef(0.3, 2.0, 0.65);
glScalef(0.3, 2.0, 0.2);
prostopadloscian();
glPopMatrix();

}


void przdłużenie()
{
glPushMatrix();
glTranslatef(0.1, 0.0, 0.0);
uchwyt();
glPopMatrix();
glPushMatrix();
glTranslatef(-0.9, 2.0, 0.3);
glScalef(2.5, -1.0, 0.9);
prostopadloscian();
glPopMatrix();
glPushMatrix();
glTranslatef(-0.2, 4.0, 0.6);
glScalef(1.8, 0.2, 0.2);
prostopadloscian();
glPopMatrix();
}



void wahadło()
{

glPushMatrix();
glTranslatef(-1.0, 2.0, 4.2);
glRotatef(-45.0, 0.0, 1.0, 0.0);
glTranslatef(-0.95, 0.0, -0.95);
przdłużenie();
glPopMatrix();
}



void start()
{
glClearColor(1.0,1.0,1.0,1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0, 1.0, 0.1, 30.0);
gluLookAt(10.0, 10.0, 12.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
wahadło();
glFlush();
}

void main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
glutInitWindowSize(800,600);
glutInitWindowPosition(100,100);
glutCreateWindow("Wahadło");
glutDisplayFunc(start);
glutMainLoop();
}

#2 mateusz midor

    Nowy na forum

  • Użytkownicy
  • 6 Postów:

Napisano pon, 07 mar 2011 - 13:40

Cześć,
rozumiem że nie chcesz symulować prawdziwego wahadła matematycznego (albo nie daj Boże fizycznego wink.gif), tylko zrobić animację wahadła?
W tym celu rysujesz sobie wahadło biegnące od punktu vertex(0, 0, 0) do np vertex(0, -5, 0) - na początek może to być po prostu zwykła linia GL_LINES, a animujesz go przy użyciu np funkcji sinus;
czyli:

//begin scene

glLoadIdentity();
static int counter = 0;
// wychylenie max 30 stopni
glRotatef(0, 0, 30.0 * sin(counter * 3.1415 / 180.0))
glBegin(GL_LINES);
glVertex3f(0,0,0);
glVertex3f(0,-5,0);
glEnd();
counter++;

//end scene

Tak bym to widział, w najprostszym ujęciu wink.gif

#3 Jason

    Avatar

  • Super użytkownicy
  • 1118 Postów:

Napisano pon, 07 mar 2011 - 14:32

Co wam z tym wrzucaniem kodu bez tagów :/ ?

"Mam problem, patrzcie:"



# -*- coding: utf-8 -*-
import math

from Vector import Vector

class PhysicsEngine:
def __init__(self,jedi,blasterManager,clashManager):
self.blasters=blasterManager.blasters
self.clashManager=clashManager
self.drop_blasters=[]
self.jedi=jedi

self.Iterations=10
self.step_size=1.0/float(self.Iterations)

self.blaster_segments=((0,1),(1,2),(2,3),(3,0))
self.ls_segments=((2,0),(1,3),(0,1),(2,3))
self.jedi_segments=((0,1),(1,3),(3,2),(2,0))
#print self.segmentsCrossingPoint((2.0,2.0),(4.0,-3.0),(7.0,1.0),(2.0,-2.0))
#print self.intersect(Vector(1.0,1.0),Vector(3.0,3.0),Vector(1.0,2.0),Vector(4.0,10.0))
def angleToVec(self,angle):
return Vector(-math.sin(math.radians(angle)),math.cos(math.radians(angle))) # blasters rest position is vertical (-sin...)
def vecToAngle(self,V):
return math.degrees(math.atan2(V.Y,V.X))-90.0 # blasters rest position is vertical (-90)
def segmentNormal(self,A,cool.gif:
return A[1]-B[1],B[0]-A[0]
def segmentsCrossingPoint(self,A,B,C,D):
ABa=A[1]-B[1]
ABb=B[0]-A[0]
ABc=A[1]*(A[0]-B[0])+A[0]*(B[1]-A[1])

CDa=C[1]-D[1]
CDb=D[0]-C[0]
CDc=C[1]*(C[0]-D[0])+C[0]*(D[1]-C[1])

wAB=ABa*CDb-CDa*ABb
wBC=ABb*CDc-CDb*ABc
wCA=ABc*CDa-CDc*ABa

if wAB!=0:
return wBC/wAB,wCA/wAB
else:
return 0.0,0.0

def segmentCenter(self,A,cool.gif:
return 0.5*(A[0]+B[0]), 0.5*(A[1]+B[1])

def ccw(self,A,B,C):
return (C.Y-A.Y)*(B.X-A.X) > (B.Y-A.Y)*(C.X-A.X)

def intersect(self,A,B,C,D):
return self.ccw(A,C,D) != self.ccw(B,C,D) and self.ccw(A,B,C) != self.ccw(A,B,D)

def SegmentToSegmentCollision(self,S1A,S1B,S2A,S2B):
return self.intersect(Vector(S1A),Vector(S1B),Vector(S2A),Vector(S2B))


def step(self):
for I in range(0,self.Iterations):
self.jedi.process(self.step_size)

for blaster in self.blasters:
if not blaster.reflected:
blaster.shift(self.step_size)
if self.RectToRectCollision(self.jedi.ls_bbox,blaster.bbox):
self.jedi.refresh_ls_bbox()
blaster.setRotation(blaster.angle)
left,right,top,bottom=False,False,False,False

for bl_segment in self.blaster_segments:
if self.SegmentToSegmentCollision(self.jedi.ls_bbox[self.ls_segments[0][0]],self.jedi.ls_bbox[self.ls_segments[0][1]],
blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]]):
#angle=2.0*self.jedi.ls_rot-blaster.angle
#angle=self.jedi.ls_rot # jak walnie w czubek
left=True
point1=self.segmentsCrossingPoint(blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]],
self.jedi.ls_bbox[self.ls_segments[0][0]],self.jedi.ls_bbox[self.ls_segments[0][1]] )
break

for bl_segment in self.blaster_segments:
if self.SegmentToSegmentCollision(self.jedi.ls_bbox[self.ls_segments[1][0]],self.jedi.ls_bbox[self.ls_segments[1][1]],
blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]]):
right=True
point1=self.segmentsCrossingPoint(blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]],
self.jedi.ls_bbox[self.ls_segments[1][0]],self.jedi.ls_bbox[self.ls_segments[1][1]] )
break
for bl_segment in self.blaster_segments:
if self.SegmentToSegmentCollision(self.jedi.ls_bbox[self.ls_segments[2][0]],self.jedi.ls_bbox[self.ls_segments[2][1]],
blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]]):
top=True
point2=self.segmentsCrossingPoint(blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]],
self.jedi.ls_bbox[self.ls_segments[2][0]],self.jedi.ls_bbox[self.ls_segments[2][1]] )
break
for bl_segment in self.blaster_segments:
if self.SegmentToSegmentCollision(self.jedi.ls_bbox[self.ls_segments[3][0]],self.jedi.ls_bbox[self.ls_segments[3][1]],
blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]]):
bottom=True
point2=self.segmentsCrossingPoint(blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]],
self.jedi.ls_bbox[self.ls_segments[3][0]],self.jedi.ls_bbox[self.ls_segments[3][1]] )
break

if top and left:
blaster.linearVelocity.X,blaster.linearVelocity.Y=self.segmentNormal(self.jedi.ls_bbox[self.ls_segments[0][0]],self.jedi.ls_bbox[self.ls_segments[0][1]])
angle=self.vecToAngle(blaster.linearVelocity)
angle-=45.0
blaster.linearVelocity=self.angleToVec(angle)
point=self.segmentCenter(point1,point2)
elif top and right:
blaster.linearVelocity.X,blaster.linearVelocity.Y=self.segmentNormal(self.jedi.ls_bbox[self.ls_segments[1][0]],self.jedi.ls_bbox[self.ls_segments[1][1]])
angle=self.vecToAngle(blaster.linearVelocity)
angle+=45.0
blaster.linearVelocity=self.angleToVec(angle)
point=self.segmentCenter(point1,point2)
elif bottom and left:
blaster.linearVelocity.X,blaster.linearVelocity.Y=self.segmentNormal(self.jedi.ls_bbox[self.ls_segments[0][0]],self.jedi.ls_bbox[self.ls_segments[0][1]])
angle=self.vecToAngle(blaster.linearVelocity)
angle+=45.0
blaster.linearVelocity=self.angleToVec(angle)
point=self.segmentCenter(point1,point2)
elif bottom and right:
blaster.linearVelocity.X,blaster.linearVelocity.Y=self.segmentNormal(self.jedi.ls_bbox[self.ls_segments[1][0]],self.jedi.ls_bbox[self.ls_segments[1][1]])
angle=self.vecToAngle(blaster.linearVelocity)
angle-=45.0
blaster.linearVelocity=self.angleToVec(angle)
point=self.segmentCenter(point1,point2)
elif left:
blaster.linearVelocity.X,blaster.linearVelocity.Y=self.segmentNormal(self.jedi.ls_bbox[self.ls_segments[0][0]],self.jedi.ls_bbox[self.ls_segments[0][1]])
point=point1
elif right:
blaster.linearVelocity.X,blaster.linearVelocity.Y=self.segmentNormal(self.jedi.ls_bbox[self.ls_segments[1][0]],self.jedi.ls_bbox[self.ls_segments[1][1]])
point=point1
elif top:
angle=self.jedi.ls_rot
blaster.linearVelocity=self.angleToVec(angle)
point=point2
elif bottom:
angle=self.jedi.ls_rot+180.0
blaster.linearVelocity=self.angleToVec(angle)
point=point2

if (left,right,top,bottom)!=(False,False,False,False):
blaster.setRotation(self.vecToAngle(blaster.linearVelocity))
blaster.linearVelocity.Normalize()
blaster.linearVelocity*=0.3
blaster.reflected=True
self.jedi.doReflect()
self.clashManager.appendClash(point)

if self.RectToRectCollision(self.jedi.bbox,blaster.bbox):
self.jedi.getHit()
for jedi_segment in self.jedi_segments:
for bl_segment in self.blaster_segments:
if self.SegmentToSegmentCollision(self.jedi.bbox[jedi_segment[0]],self.jedi.bbox[jedi_segment[1]],
blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]]):
bottom=True
point=self.segmentsCrossingPoint(blaster.bbox[bl_segment[0]],blaster.bbox[bl_segment[1]],
self.jedi.bbox[jedi_segment[0]],self.jedi.bbox[jedi_segment[1]] )
blaster.reflected=True
break
if blaster.reflected:
self.clashManager.appendHit(point)
break
self.drop_blasters.append(blaster)

for blaster in self.drop_blasters:
self.blasters.remove(blaster)
self.drop_blasters=[]

def appendBlaster(self,blaster):
self.blasters.append(blaster)

def reorganize_points(self,rect): # cztery punkty w kolejnosci: gorny lewy, gorny prawy, dolny lewy, dolny prawy
rect.sort(cmp=lambda x,y: cmp(y[1],x[1]))
for i in [0,2]:
if rect[i][0]>rect[i+1][0]:
tmp=rect[i+1]
rect[i+1]=rect[i]
rect[i]=tmp
def RectToRectCollision(self,A,cool.gif:
#Setting Up
self.reorganize_points(A)
self.reorganize_points(cool.gif
#Step 1 okreslenie osi
Axis=[]
Axis.append([A[1][0] - A[0][0],A[1][1] - A[0][1]])
Axis.append([A[1][0] - A[3][0],A[1][1] - A[3][1]])
Axis.append([B[0][0] - B[2][0],B[0][1] - B[2][1]])
Axis.append([B[0][0] - B[1][0],B[0][1] - B[1][1]])
for axis in Axis:
scalarsA=[]
scalarsB=[]
for point in A:
#Step 2 projekcja wektorow reprezentujacych cztery katy kazdego prostokata na kazdej osi
tmp=(point[0]*axis[0]+point[1]*axis[1])/(axis[0]**2+axis[1]**2)
x=axis[0]*tmp
y=axis[1]*tmp
#Step 3 obliczanie wartosci skalarnej
scalarsA.append(x*axis[0]+y*axis[1])
for point in B:
#Step 2 projekcja wektorow reprezentujacych cztery katy kazdego prostokata na kazdej osi
tmp=(point[0]*axis[0]+point[1]*axis[1])/(axis[0]**2+axis[1]**2)
x=axis[0]*tmp
y=axis[1]*tmp
#Step 3 obliczanie wartosci skalarnej
scalarsB.append(x*axis[0]+y*axis[1])
#Step 4 sprawdzenie maksymalnej i minimalnej wartosci skalarnej
maxA=max(scalarsA)
minA=min(scalarsA)
maxB=max(scalarsB)
minB=min(scalarsB)
if minB>maxA or maxB<minA:
return False
return True



"dobrze się Wam czyta taki kod, bo mi znakomicie"

#4 spike

    Pomocna dłoń

  • Super użytkownicy
  • 181 Postów:

Napisano pon, 07 mar 2011 - 15:57

blink.gif Jason ohmy.gif

Opisz swój problem, która linijka xD

#5 Jason

    Avatar

  • Super użytkownicy
  • 1118 Postów:

Napisano pon, 07 mar 2011 - 15:59

A więc problem jest w tym, że to działa, temat do zamknięcia biggrin.gif

#6 KaYou

    Pomocna dłoń

  • Super użytkownicy
  • 269 Postów:
  • Gadu-Gadu:1438618

Napisano pon, 07 mar 2011 - 20:48

Tak poza, to troszeczke z was archeolodzy.

#7 spike

    Pomocna dłoń

  • Super użytkownicy
  • 181 Postów:

Napisano pon, 07 mar 2011 - 21:29

cool.gif Ma się fach...

Czasem dobrze jest zobaczyć "odświeżony" temat, bo widać przynajmniej, że ktoś czyta starsze posty... sleep.gif

#8 Jason

    Avatar

  • Super użytkownicy
  • 1118 Postów:

Napisano pon, 07 mar 2011 - 21:40

No ba, na wykop trzeba dać biggrin.gif

A poza tym to odkopał ten, który pierwszy odpowiedział wink.gif