Skocz do zawartości

Wahadło


bazer

Polecane posty

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();

}

Link do komentarza
Udostępnij na innych stronach

  • 3 months later...

Cześć,

rozumiem że nie chcesz symulować prawdziwego wahadła matematycznego (albo nie daj Boże fizycznego ;)), 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 ;)

Link do komentarza
Udostępnij na innych stronach

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,B):

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,B):

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[0]>rect[i+1][0]:

tmp=rect[i+1]

rect[i+1]=rect

rect=tmp

def RectToRectCollision(self,A,B):

#Setting Up

self.reorganize_points(A)

self.reorganize_points(B)

#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

return False

return True

 

 

 

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

Link do komentarza
Udostępnij na innych stronach

Zarchiwizowany

Ten temat jest archiwizowany i nie można dodawać nowych odpowiedzi.

×
×
  • Utwórz nowe...